AWS SDK for C++

AWS SDK for C++ Version 1.11.440

Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Friends | List of all members
Aws::Lightsail::LightsailClient Class Reference

#include <LightsailClient.h>

Inheritance diagram for Aws::Lightsail::LightsailClient:
[legend]

Public Types

 
 
 

Public Types inherited from Aws::Client::AWSJsonClient

 

Public Member Functions

 
 
 LightsailClient (const std::shared_ptr< Aws::Auth::AWSCredentialsProvider > &credentialsProvider, std::shared_ptr< LightsailEndpointProviderBase > endpointProvider=nullptr, const Aws::Lightsail::LightsailClientConfiguration &clientConfiguration=Aws::Lightsail::LightsailClientConfiguration())
 
 LightsailClient (const Aws::Client::ClientConfiguration &clientConfiguration)
 
 LightsailClient (const Aws::Auth::AWSCredentials &credentials, const Aws::Client::ClientConfiguration &clientConfiguration)
 
 LightsailClient (const std::shared_ptr< Aws::Auth::AWSCredentialsProvider > &credentialsProvider, const Aws::Client::ClientConfiguration &clientConfiguration)
 
virtual ~LightsailClient ()
 
 
template<typename AllocateStaticIpRequestT = Model::AllocateStaticIpRequest>
Model::AllocateStaticIpOutcomeCallable AllocateStaticIpCallable (const AllocateStaticIpRequestT &request) const
 
template<typename AllocateStaticIpRequestT = Model::AllocateStaticIpRequest>
void AllocateStaticIpAsync (const AllocateStaticIpRequestT &request, const AllocateStaticIpResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AttachCertificateToDistributionRequestT = Model::AttachCertificateToDistributionRequest>
Model::AttachCertificateToDistributionOutcomeCallable AttachCertificateToDistributionCallable (const AttachCertificateToDistributionRequestT &request) const
 
template<typename AttachCertificateToDistributionRequestT = Model::AttachCertificateToDistributionRequest>
void AttachCertificateToDistributionAsync (const AttachCertificateToDistributionRequestT &request, const AttachCertificateToDistributionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AttachDiskRequestT = Model::AttachDiskRequest>
Model::AttachDiskOutcomeCallable AttachDiskCallable (const AttachDiskRequestT &request) const
 
template<typename AttachDiskRequestT = Model::AttachDiskRequest>
void AttachDiskAsync (const AttachDiskRequestT &request, const AttachDiskResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AttachInstancesToLoadBalancerRequestT = Model::AttachInstancesToLoadBalancerRequest>
Model::AttachInstancesToLoadBalancerOutcomeCallable AttachInstancesToLoadBalancerCallable (const AttachInstancesToLoadBalancerRequestT &request) const
 
template<typename AttachInstancesToLoadBalancerRequestT = Model::AttachInstancesToLoadBalancerRequest>
void AttachInstancesToLoadBalancerAsync (const AttachInstancesToLoadBalancerRequestT &request, const AttachInstancesToLoadBalancerResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AttachLoadBalancerTlsCertificateRequestT = Model::AttachLoadBalancerTlsCertificateRequest>
Model::AttachLoadBalancerTlsCertificateOutcomeCallable AttachLoadBalancerTlsCertificateCallable (const AttachLoadBalancerTlsCertificateRequestT &request) const
 
template<typename AttachLoadBalancerTlsCertificateRequestT = Model::AttachLoadBalancerTlsCertificateRequest>
void AttachLoadBalancerTlsCertificateAsync (const AttachLoadBalancerTlsCertificateRequestT &request, const AttachLoadBalancerTlsCertificateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AttachStaticIpRequestT = Model::AttachStaticIpRequest>
Model::AttachStaticIpOutcomeCallable AttachStaticIpCallable (const AttachStaticIpRequestT &request) const
 
template<typename AttachStaticIpRequestT = Model::AttachStaticIpRequest>
void AttachStaticIpAsync (const AttachStaticIpRequestT &request, const AttachStaticIpResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CloseInstancePublicPortsRequestT = Model::CloseInstancePublicPortsRequest>
Model::CloseInstancePublicPortsOutcomeCallable CloseInstancePublicPortsCallable (const CloseInstancePublicPortsRequestT &request) const
 
template<typename CloseInstancePublicPortsRequestT = Model::CloseInstancePublicPortsRequest>
void CloseInstancePublicPortsAsync (const CloseInstancePublicPortsRequestT &request, const CloseInstancePublicPortsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CopySnapshotRequestT = Model::CopySnapshotRequest>
Model::CopySnapshotOutcomeCallable CopySnapshotCallable (const CopySnapshotRequestT &request) const
 
template<typename CopySnapshotRequestT = Model::CopySnapshotRequest>
void CopySnapshotAsync (const CopySnapshotRequestT &request, const CopySnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateBucketRequestT = Model::CreateBucketRequest>
Model::CreateBucketOutcomeCallable CreateBucketCallable (const CreateBucketRequestT &request) const
 
template<typename CreateBucketRequestT = Model::CreateBucketRequest>
void CreateBucketAsync (const CreateBucketRequestT &request, const CreateBucketResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateBucketAccessKeyRequestT = Model::CreateBucketAccessKeyRequest>
Model::CreateBucketAccessKeyOutcomeCallable CreateBucketAccessKeyCallable (const CreateBucketAccessKeyRequestT &request) const
 
template<typename CreateBucketAccessKeyRequestT = Model::CreateBucketAccessKeyRequest>
void CreateBucketAccessKeyAsync (const CreateBucketAccessKeyRequestT &request, const CreateBucketAccessKeyResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateCertificateRequestT = Model::CreateCertificateRequest>
Model::CreateCertificateOutcomeCallable CreateCertificateCallable (const CreateCertificateRequestT &request) const
 
template<typename CreateCertificateRequestT = Model::CreateCertificateRequest>
void CreateCertificateAsync (const CreateCertificateRequestT &request, const CreateCertificateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateCloudFormationStackRequestT = Model::CreateCloudFormationStackRequest>
Model::CreateCloudFormationStackOutcomeCallable CreateCloudFormationStackCallable (const CreateCloudFormationStackRequestT &request) const
 
template<typename CreateCloudFormationStackRequestT = Model::CreateCloudFormationStackRequest>
void CreateCloudFormationStackAsync (const CreateCloudFormationStackRequestT &request, const CreateCloudFormationStackResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateContactMethodRequestT = Model::CreateContactMethodRequest>
Model::CreateContactMethodOutcomeCallable CreateContactMethodCallable (const CreateContactMethodRequestT &request) const
 
template<typename CreateContactMethodRequestT = Model::CreateContactMethodRequest>
void CreateContactMethodAsync (const CreateContactMethodRequestT &request, const CreateContactMethodResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateContainerServiceRequestT = Model::CreateContainerServiceRequest>
Model::CreateContainerServiceOutcomeCallable CreateContainerServiceCallable (const CreateContainerServiceRequestT &request) const
 
template<typename CreateContainerServiceRequestT = Model::CreateContainerServiceRequest>
void CreateContainerServiceAsync (const CreateContainerServiceRequestT &request, const CreateContainerServiceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateContainerServiceDeploymentRequestT = Model::CreateContainerServiceDeploymentRequest>
Model::CreateContainerServiceDeploymentOutcomeCallable CreateContainerServiceDeploymentCallable (const CreateContainerServiceDeploymentRequestT &request) const
 
template<typename CreateContainerServiceDeploymentRequestT = Model::CreateContainerServiceDeploymentRequest>
void CreateContainerServiceDeploymentAsync (const CreateContainerServiceDeploymentRequestT &request, const CreateContainerServiceDeploymentResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateContainerServiceRegistryLoginRequestT = Model::CreateContainerServiceRegistryLoginRequest>
Model::CreateContainerServiceRegistryLoginOutcomeCallable CreateContainerServiceRegistryLoginCallable (const CreateContainerServiceRegistryLoginRequestT &request={}) const
 
template<typename CreateContainerServiceRegistryLoginRequestT = Model::CreateContainerServiceRegistryLoginRequest>
void CreateContainerServiceRegistryLoginAsync (const CreateContainerServiceRegistryLoginResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const CreateContainerServiceRegistryLoginRequestT &request={}) const
 
 
template<typename CreateDiskRequestT = Model::CreateDiskRequest>
Model::CreateDiskOutcomeCallable CreateDiskCallable (const CreateDiskRequestT &request) const
 
template<typename CreateDiskRequestT = Model::CreateDiskRequest>
void CreateDiskAsync (const CreateDiskRequestT &request, const CreateDiskResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateDiskFromSnapshotRequestT = Model::CreateDiskFromSnapshotRequest>
Model::CreateDiskFromSnapshotOutcomeCallable CreateDiskFromSnapshotCallable (const CreateDiskFromSnapshotRequestT &request) const
 
template<typename CreateDiskFromSnapshotRequestT = Model::CreateDiskFromSnapshotRequest>
void CreateDiskFromSnapshotAsync (const CreateDiskFromSnapshotRequestT &request, const CreateDiskFromSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateDiskSnapshotRequestT = Model::CreateDiskSnapshotRequest>
Model::CreateDiskSnapshotOutcomeCallable CreateDiskSnapshotCallable (const CreateDiskSnapshotRequestT &request) const
 
template<typename CreateDiskSnapshotRequestT = Model::CreateDiskSnapshotRequest>
void CreateDiskSnapshotAsync (const CreateDiskSnapshotRequestT &request, const CreateDiskSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateDistributionRequestT = Model::CreateDistributionRequest>
Model::CreateDistributionOutcomeCallable CreateDistributionCallable (const CreateDistributionRequestT &request) const
 
template<typename CreateDistributionRequestT = Model::CreateDistributionRequest>
void CreateDistributionAsync (const CreateDistributionRequestT &request, const CreateDistributionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateDomainRequestT = Model::CreateDomainRequest>
Model::CreateDomainOutcomeCallable CreateDomainCallable (const CreateDomainRequestT &request) const
 
template<typename CreateDomainRequestT = Model::CreateDomainRequest>
void CreateDomainAsync (const CreateDomainRequestT &request, const CreateDomainResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateDomainEntryRequestT = Model::CreateDomainEntryRequest>
Model::CreateDomainEntryOutcomeCallable CreateDomainEntryCallable (const CreateDomainEntryRequestT &request) const
 
template<typename CreateDomainEntryRequestT = Model::CreateDomainEntryRequest>
void CreateDomainEntryAsync (const CreateDomainEntryRequestT &request, const CreateDomainEntryResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateGUISessionAccessDetailsRequestT = Model::CreateGUISessionAccessDetailsRequest>
Model::CreateGUISessionAccessDetailsOutcomeCallable CreateGUISessionAccessDetailsCallable (const CreateGUISessionAccessDetailsRequestT &request) const
 
template<typename CreateGUISessionAccessDetailsRequestT = Model::CreateGUISessionAccessDetailsRequest>
void CreateGUISessionAccessDetailsAsync (const CreateGUISessionAccessDetailsRequestT &request, const CreateGUISessionAccessDetailsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateInstanceSnapshotRequestT = Model::CreateInstanceSnapshotRequest>
Model::CreateInstanceSnapshotOutcomeCallable CreateInstanceSnapshotCallable (const CreateInstanceSnapshotRequestT &request) const
 
template<typename CreateInstanceSnapshotRequestT = Model::CreateInstanceSnapshotRequest>
void CreateInstanceSnapshotAsync (const CreateInstanceSnapshotRequestT &request, const CreateInstanceSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateInstancesRequestT = Model::CreateInstancesRequest>
Model::CreateInstancesOutcomeCallable CreateInstancesCallable (const CreateInstancesRequestT &request) const
 
template<typename CreateInstancesRequestT = Model::CreateInstancesRequest>
void CreateInstancesAsync (const CreateInstancesRequestT &request, const CreateInstancesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateInstancesFromSnapshotRequestT = Model::CreateInstancesFromSnapshotRequest>
Model::CreateInstancesFromSnapshotOutcomeCallable CreateInstancesFromSnapshotCallable (const CreateInstancesFromSnapshotRequestT &request) const
 
template<typename CreateInstancesFromSnapshotRequestT = Model::CreateInstancesFromSnapshotRequest>
void CreateInstancesFromSnapshotAsync (const CreateInstancesFromSnapshotRequestT &request, const CreateInstancesFromSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateKeyPairRequestT = Model::CreateKeyPairRequest>
Model::CreateKeyPairOutcomeCallable CreateKeyPairCallable (const CreateKeyPairRequestT &request) const
 
template<typename CreateKeyPairRequestT = Model::CreateKeyPairRequest>
void CreateKeyPairAsync (const CreateKeyPairRequestT &request, const CreateKeyPairResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateLoadBalancerRequestT = Model::CreateLoadBalancerRequest>
Model::CreateLoadBalancerOutcomeCallable CreateLoadBalancerCallable (const CreateLoadBalancerRequestT &request) const
 
template<typename CreateLoadBalancerRequestT = Model::CreateLoadBalancerRequest>
void CreateLoadBalancerAsync (const CreateLoadBalancerRequestT &request, const CreateLoadBalancerResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateLoadBalancerTlsCertificateRequestT = Model::CreateLoadBalancerTlsCertificateRequest>
Model::CreateLoadBalancerTlsCertificateOutcomeCallable CreateLoadBalancerTlsCertificateCallable (const CreateLoadBalancerTlsCertificateRequestT &request) const
 
template<typename CreateLoadBalancerTlsCertificateRequestT = Model::CreateLoadBalancerTlsCertificateRequest>
void CreateLoadBalancerTlsCertificateAsync (const CreateLoadBalancerTlsCertificateRequestT &request, const CreateLoadBalancerTlsCertificateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateRelationalDatabaseRequestT = Model::CreateRelationalDatabaseRequest>
Model::CreateRelationalDatabaseOutcomeCallable CreateRelationalDatabaseCallable (const CreateRelationalDatabaseRequestT &request) const
 
template<typename CreateRelationalDatabaseRequestT = Model::CreateRelationalDatabaseRequest>
void CreateRelationalDatabaseAsync (const CreateRelationalDatabaseRequestT &request, const CreateRelationalDatabaseResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateRelationalDatabaseFromSnapshotRequestT = Model::CreateRelationalDatabaseFromSnapshotRequest>
Model::CreateRelationalDatabaseFromSnapshotOutcomeCallable CreateRelationalDatabaseFromSnapshotCallable (const CreateRelationalDatabaseFromSnapshotRequestT &request) const
 
template<typename CreateRelationalDatabaseFromSnapshotRequestT = Model::CreateRelationalDatabaseFromSnapshotRequest>
void CreateRelationalDatabaseFromSnapshotAsync (const CreateRelationalDatabaseFromSnapshotRequestT &request, const CreateRelationalDatabaseFromSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateRelationalDatabaseSnapshotRequestT = Model::CreateRelationalDatabaseSnapshotRequest>
Model::CreateRelationalDatabaseSnapshotOutcomeCallable CreateRelationalDatabaseSnapshotCallable (const CreateRelationalDatabaseSnapshotRequestT &request) const
 
template<typename CreateRelationalDatabaseSnapshotRequestT = Model::CreateRelationalDatabaseSnapshotRequest>
void CreateRelationalDatabaseSnapshotAsync (const CreateRelationalDatabaseSnapshotRequestT &request, const CreateRelationalDatabaseSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteAlarmRequestT = Model::DeleteAlarmRequest>
Model::DeleteAlarmOutcomeCallable DeleteAlarmCallable (const DeleteAlarmRequestT &request) const
 
template<typename DeleteAlarmRequestT = Model::DeleteAlarmRequest>
void DeleteAlarmAsync (const DeleteAlarmRequestT &request, const DeleteAlarmResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteAutoSnapshotRequestT = Model::DeleteAutoSnapshotRequest>
Model::DeleteAutoSnapshotOutcomeCallable DeleteAutoSnapshotCallable (const DeleteAutoSnapshotRequestT &request) const
 
template<typename DeleteAutoSnapshotRequestT = Model::DeleteAutoSnapshotRequest>
void DeleteAutoSnapshotAsync (const DeleteAutoSnapshotRequestT &request, const DeleteAutoSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteBucketRequestT = Model::DeleteBucketRequest>
Model::DeleteBucketOutcomeCallable DeleteBucketCallable (const DeleteBucketRequestT &request) const
 
template<typename DeleteBucketRequestT = Model::DeleteBucketRequest>
void DeleteBucketAsync (const DeleteBucketRequestT &request, const DeleteBucketResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteBucketAccessKeyRequestT = Model::DeleteBucketAccessKeyRequest>
Model::DeleteBucketAccessKeyOutcomeCallable DeleteBucketAccessKeyCallable (const DeleteBucketAccessKeyRequestT &request) const
 
template<typename DeleteBucketAccessKeyRequestT = Model::DeleteBucketAccessKeyRequest>
void DeleteBucketAccessKeyAsync (const DeleteBucketAccessKeyRequestT &request, const DeleteBucketAccessKeyResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteCertificateRequestT = Model::DeleteCertificateRequest>
Model::DeleteCertificateOutcomeCallable DeleteCertificateCallable (const DeleteCertificateRequestT &request) const
 
template<typename DeleteCertificateRequestT = Model::DeleteCertificateRequest>
void DeleteCertificateAsync (const DeleteCertificateRequestT &request, const DeleteCertificateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteContactMethodRequestT = Model::DeleteContactMethodRequest>
Model::DeleteContactMethodOutcomeCallable DeleteContactMethodCallable (const DeleteContactMethodRequestT &request) const
 
template<typename DeleteContactMethodRequestT = Model::DeleteContactMethodRequest>
void DeleteContactMethodAsync (const DeleteContactMethodRequestT &request, const DeleteContactMethodResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteContainerImageRequestT = Model::DeleteContainerImageRequest>
Model::DeleteContainerImageOutcomeCallable DeleteContainerImageCallable (const DeleteContainerImageRequestT &request) const
 
template<typename DeleteContainerImageRequestT = Model::DeleteContainerImageRequest>
void DeleteContainerImageAsync (const DeleteContainerImageRequestT &request, const DeleteContainerImageResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteContainerServiceRequestT = Model::DeleteContainerServiceRequest>
Model::DeleteContainerServiceOutcomeCallable DeleteContainerServiceCallable (const DeleteContainerServiceRequestT &request) const
 
template<typename DeleteContainerServiceRequestT = Model::DeleteContainerServiceRequest>
void DeleteContainerServiceAsync (const DeleteContainerServiceRequestT &request, const DeleteContainerServiceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteDiskRequestT = Model::DeleteDiskRequest>
Model::DeleteDiskOutcomeCallable DeleteDiskCallable (const DeleteDiskRequestT &request) const
 
template<typename DeleteDiskRequestT = Model::DeleteDiskRequest>
void DeleteDiskAsync (const DeleteDiskRequestT &request, const DeleteDiskResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteDiskSnapshotRequestT = Model::DeleteDiskSnapshotRequest>
Model::DeleteDiskSnapshotOutcomeCallable DeleteDiskSnapshotCallable (const DeleteDiskSnapshotRequestT &request) const
 
template<typename DeleteDiskSnapshotRequestT = Model::DeleteDiskSnapshotRequest>
void DeleteDiskSnapshotAsync (const DeleteDiskSnapshotRequestT &request, const DeleteDiskSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteDistributionRequestT = Model::DeleteDistributionRequest>
Model::DeleteDistributionOutcomeCallable DeleteDistributionCallable (const DeleteDistributionRequestT &request={}) const
 
template<typename DeleteDistributionRequestT = Model::DeleteDistributionRequest>
void DeleteDistributionAsync (const DeleteDistributionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const DeleteDistributionRequestT &request={}) const
 
 
template<typename DeleteDomainRequestT = Model::DeleteDomainRequest>
Model::DeleteDomainOutcomeCallable DeleteDomainCallable (const DeleteDomainRequestT &request) const
 
template<typename DeleteDomainRequestT = Model::DeleteDomainRequest>
void DeleteDomainAsync (const DeleteDomainRequestT &request, const DeleteDomainResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteDomainEntryRequestT = Model::DeleteDomainEntryRequest>
Model::DeleteDomainEntryOutcomeCallable DeleteDomainEntryCallable (const DeleteDomainEntryRequestT &request) const
 
template<typename DeleteDomainEntryRequestT = Model::DeleteDomainEntryRequest>
void DeleteDomainEntryAsync (const DeleteDomainEntryRequestT &request, const DeleteDomainEntryResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
Model::DeleteInstanceOutcomeCallable DeleteInstanceCallable (const DeleteInstanceRequestT &request) const
 
template<typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
void DeleteInstanceAsync (const DeleteInstanceRequestT &request, const DeleteInstanceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteInstanceSnapshotRequestT = Model::DeleteInstanceSnapshotRequest>
Model::DeleteInstanceSnapshotOutcomeCallable DeleteInstanceSnapshotCallable (const DeleteInstanceSnapshotRequestT &request) const
 
template<typename DeleteInstanceSnapshotRequestT = Model::DeleteInstanceSnapshotRequest>
void DeleteInstanceSnapshotAsync (const DeleteInstanceSnapshotRequestT &request, const DeleteInstanceSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteKeyPairRequestT = Model::DeleteKeyPairRequest>
Model::DeleteKeyPairOutcomeCallable DeleteKeyPairCallable (const DeleteKeyPairRequestT &request) const
 
template<typename DeleteKeyPairRequestT = Model::DeleteKeyPairRequest>
void DeleteKeyPairAsync (const DeleteKeyPairRequestT &request, const DeleteKeyPairResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteKnownHostKeysRequestT = Model::DeleteKnownHostKeysRequest>
Model::DeleteKnownHostKeysOutcomeCallable DeleteKnownHostKeysCallable (const DeleteKnownHostKeysRequestT &request) const
 
template<typename DeleteKnownHostKeysRequestT = Model::DeleteKnownHostKeysRequest>
void DeleteKnownHostKeysAsync (const DeleteKnownHostKeysRequestT &request, const DeleteKnownHostKeysResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteLoadBalancerRequestT = Model::DeleteLoadBalancerRequest>
Model::DeleteLoadBalancerOutcomeCallable DeleteLoadBalancerCallable (const DeleteLoadBalancerRequestT &request) const
 
template<typename DeleteLoadBalancerRequestT = Model::DeleteLoadBalancerRequest>
void DeleteLoadBalancerAsync (const DeleteLoadBalancerRequestT &request, const DeleteLoadBalancerResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteLoadBalancerTlsCertificateRequestT = Model::DeleteLoadBalancerTlsCertificateRequest>
Model::DeleteLoadBalancerTlsCertificateOutcomeCallable DeleteLoadBalancerTlsCertificateCallable (const DeleteLoadBalancerTlsCertificateRequestT &request) const
 
template<typename DeleteLoadBalancerTlsCertificateRequestT = Model::DeleteLoadBalancerTlsCertificateRequest>
void DeleteLoadBalancerTlsCertificateAsync (const DeleteLoadBalancerTlsCertificateRequestT &request, const DeleteLoadBalancerTlsCertificateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteRelationalDatabaseRequestT = Model::DeleteRelationalDatabaseRequest>
Model::DeleteRelationalDatabaseOutcomeCallable DeleteRelationalDatabaseCallable (const DeleteRelationalDatabaseRequestT &request) const
 
template<typename DeleteRelationalDatabaseRequestT = Model::DeleteRelationalDatabaseRequest>
void DeleteRelationalDatabaseAsync (const DeleteRelationalDatabaseRequestT &request, const DeleteRelationalDatabaseResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteRelationalDatabaseSnapshotRequestT = Model::DeleteRelationalDatabaseSnapshotRequest>
Model::DeleteRelationalDatabaseSnapshotOutcomeCallable DeleteRelationalDatabaseSnapshotCallable (const DeleteRelationalDatabaseSnapshotRequestT &request) const
 
template<typename DeleteRelationalDatabaseSnapshotRequestT = Model::DeleteRelationalDatabaseSnapshotRequest>
void DeleteRelationalDatabaseSnapshotAsync (const DeleteRelationalDatabaseSnapshotRequestT &request, const DeleteRelationalDatabaseSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DetachCertificateFromDistributionRequestT = Model::DetachCertificateFromDistributionRequest>
Model::DetachCertificateFromDistributionOutcomeCallable DetachCertificateFromDistributionCallable (const DetachCertificateFromDistributionRequestT &request) const
 
template<typename DetachCertificateFromDistributionRequestT = Model::DetachCertificateFromDistributionRequest>
void DetachCertificateFromDistributionAsync (const DetachCertificateFromDistributionRequestT &request, const DetachCertificateFromDistributionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DetachDiskRequestT = Model::DetachDiskRequest>
Model::DetachDiskOutcomeCallable DetachDiskCallable (const DetachDiskRequestT &request) const
 
template<typename DetachDiskRequestT = Model::DetachDiskRequest>
void DetachDiskAsync (const DetachDiskRequestT &request, const DetachDiskResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DetachInstancesFromLoadBalancerRequestT = Model::DetachInstancesFromLoadBalancerRequest>
Model::DetachInstancesFromLoadBalancerOutcomeCallable DetachInstancesFromLoadBalancerCallable (const DetachInstancesFromLoadBalancerRequestT &request) const
 
template<typename DetachInstancesFromLoadBalancerRequestT = Model::DetachInstancesFromLoadBalancerRequest>
void DetachInstancesFromLoadBalancerAsync (const DetachInstancesFromLoadBalancerRequestT &request, const DetachInstancesFromLoadBalancerResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DetachStaticIpRequestT = Model::DetachStaticIpRequest>
Model::DetachStaticIpOutcomeCallable DetachStaticIpCallable (const DetachStaticIpRequestT &request) const
 
template<typename DetachStaticIpRequestT = Model::DetachStaticIpRequest>
void DetachStaticIpAsync (const DetachStaticIpRequestT &request, const DetachStaticIpResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DisableAddOnRequestT = Model::DisableAddOnRequest>
Model::DisableAddOnOutcomeCallable DisableAddOnCallable (const DisableAddOnRequestT &request) const
 
template<typename DisableAddOnRequestT = Model::DisableAddOnRequest>
void DisableAddOnAsync (const DisableAddOnRequestT &request, const DisableAddOnResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DownloadDefaultKeyPairRequestT = Model::DownloadDefaultKeyPairRequest>
Model::DownloadDefaultKeyPairOutcomeCallable DownloadDefaultKeyPairCallable (const DownloadDefaultKeyPairRequestT &request={}) const
 
template<typename DownloadDefaultKeyPairRequestT = Model::DownloadDefaultKeyPairRequest>
void DownloadDefaultKeyPairAsync (const DownloadDefaultKeyPairResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const DownloadDefaultKeyPairRequestT &request={}) const
 
 
template<typename EnableAddOnRequestT = Model::EnableAddOnRequest>
Model::EnableAddOnOutcomeCallable EnableAddOnCallable (const EnableAddOnRequestT &request) const
 
template<typename EnableAddOnRequestT = Model::EnableAddOnRequest>
void EnableAddOnAsync (const EnableAddOnRequestT &request, const EnableAddOnResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ExportSnapshotRequestT = Model::ExportSnapshotRequest>
Model::ExportSnapshotOutcomeCallable ExportSnapshotCallable (const ExportSnapshotRequestT &request) const
 
template<typename ExportSnapshotRequestT = Model::ExportSnapshotRequest>
void ExportSnapshotAsync (const ExportSnapshotRequestT &request, const ExportSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetActiveNamesRequestT = Model::GetActiveNamesRequest>
Model::GetActiveNamesOutcomeCallable GetActiveNamesCallable (const GetActiveNamesRequestT &request={}) const
 
template<typename GetActiveNamesRequestT = Model::GetActiveNamesRequest>
void GetActiveNamesAsync (const GetActiveNamesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetActiveNamesRequestT &request={}) const
 
virtual Model::GetAlarmsOutcome GetAlarms (const Model::GetAlarmsRequest &request={}) const
 
template<typename GetAlarmsRequestT = Model::GetAlarmsRequest>
Model::GetAlarmsOutcomeCallable GetAlarmsCallable (const GetAlarmsRequestT &request={}) const
 
template<typename GetAlarmsRequestT = Model::GetAlarmsRequest>
void GetAlarmsAsync (const GetAlarmsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetAlarmsRequestT &request={}) const
 
 
template<typename GetAutoSnapshotsRequestT = Model::GetAutoSnapshotsRequest>
Model::GetAutoSnapshotsOutcomeCallable GetAutoSnapshotsCallable (const GetAutoSnapshotsRequestT &request) const
 
template<typename GetAutoSnapshotsRequestT = Model::GetAutoSnapshotsRequest>
void GetAutoSnapshotsAsync (const GetAutoSnapshotsRequestT &request, const GetAutoSnapshotsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetBlueprintsRequestT = Model::GetBlueprintsRequest>
Model::GetBlueprintsOutcomeCallable GetBlueprintsCallable (const GetBlueprintsRequestT &request={}) const
 
template<typename GetBlueprintsRequestT = Model::GetBlueprintsRequest>
void GetBlueprintsAsync (const GetBlueprintsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetBlueprintsRequestT &request={}) const
 
 
template<typename GetBucketAccessKeysRequestT = Model::GetBucketAccessKeysRequest>
Model::GetBucketAccessKeysOutcomeCallable GetBucketAccessKeysCallable (const GetBucketAccessKeysRequestT &request) const
 
template<typename GetBucketAccessKeysRequestT = Model::GetBucketAccessKeysRequest>
void GetBucketAccessKeysAsync (const GetBucketAccessKeysRequestT &request, const GetBucketAccessKeysResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetBucketBundlesRequestT = Model::GetBucketBundlesRequest>
Model::GetBucketBundlesOutcomeCallable GetBucketBundlesCallable (const GetBucketBundlesRequestT &request={}) const
 
template<typename GetBucketBundlesRequestT = Model::GetBucketBundlesRequest>
void GetBucketBundlesAsync (const GetBucketBundlesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetBucketBundlesRequestT &request={}) const
 
 
template<typename GetBucketMetricDataRequestT = Model::GetBucketMetricDataRequest>
Model::GetBucketMetricDataOutcomeCallable GetBucketMetricDataCallable (const GetBucketMetricDataRequestT &request) const
 
template<typename GetBucketMetricDataRequestT = Model::GetBucketMetricDataRequest>
void GetBucketMetricDataAsync (const GetBucketMetricDataRequestT &request, const GetBucketMetricDataResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetBucketsRequestT = Model::GetBucketsRequest>
Model::GetBucketsOutcomeCallable GetBucketsCallable (const GetBucketsRequestT &request={}) const
 
template<typename GetBucketsRequestT = Model::GetBucketsRequest>
void GetBucketsAsync (const GetBucketsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetBucketsRequestT &request={}) const
 
 
template<typename GetBundlesRequestT = Model::GetBundlesRequest>
Model::GetBundlesOutcomeCallable GetBundlesCallable (const GetBundlesRequestT &request={}) const
 
template<typename GetBundlesRequestT = Model::GetBundlesRequest>
void GetBundlesAsync (const GetBundlesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetBundlesRequestT &request={}) const
 
 
template<typename GetCertificatesRequestT = Model::GetCertificatesRequest>
Model::GetCertificatesOutcomeCallable GetCertificatesCallable (const GetCertificatesRequestT &request={}) const
 
template<typename GetCertificatesRequestT = Model::GetCertificatesRequest>
void GetCertificatesAsync (const GetCertificatesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetCertificatesRequestT &request={}) const
 
 
template<typename GetCloudFormationStackRecordsRequestT = Model::GetCloudFormationStackRecordsRequest>
Model::GetCloudFormationStackRecordsOutcomeCallable GetCloudFormationStackRecordsCallable (const GetCloudFormationStackRecordsRequestT &request={}) const
 
template<typename GetCloudFormationStackRecordsRequestT = Model::GetCloudFormationStackRecordsRequest>
void GetCloudFormationStackRecordsAsync (const GetCloudFormationStackRecordsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetCloudFormationStackRecordsRequestT &request={}) const
 
 
template<typename GetContactMethodsRequestT = Model::GetContactMethodsRequest>
Model::GetContactMethodsOutcomeCallable GetContactMethodsCallable (const GetContactMethodsRequestT &request={}) const
 
template<typename GetContactMethodsRequestT = Model::GetContactMethodsRequest>
void GetContactMethodsAsync (const GetContactMethodsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetContactMethodsRequestT &request={}) const
 
 
template<typename GetContainerAPIMetadataRequestT = Model::GetContainerAPIMetadataRequest>
Model::GetContainerAPIMetadataOutcomeCallable GetContainerAPIMetadataCallable (const GetContainerAPIMetadataRequestT &request={}) const
 
template<typename GetContainerAPIMetadataRequestT = Model::GetContainerAPIMetadataRequest>
void GetContainerAPIMetadataAsync (const GetContainerAPIMetadataResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetContainerAPIMetadataRequestT &request={}) const
 
 
template<typename GetContainerImagesRequestT = Model::GetContainerImagesRequest>
Model::GetContainerImagesOutcomeCallable GetContainerImagesCallable (const GetContainerImagesRequestT &request) const
 
template<typename GetContainerImagesRequestT = Model::GetContainerImagesRequest>
void GetContainerImagesAsync (const GetContainerImagesRequestT &request, const GetContainerImagesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetContainerLogRequestT = Model::GetContainerLogRequest>
Model::GetContainerLogOutcomeCallable GetContainerLogCallable (const GetContainerLogRequestT &request) const
 
template<typename GetContainerLogRequestT = Model::GetContainerLogRequest>
void GetContainerLogAsync (const GetContainerLogRequestT &request, const GetContainerLogResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetContainerServiceDeploymentsRequestT = Model::GetContainerServiceDeploymentsRequest>
Model::GetContainerServiceDeploymentsOutcomeCallable GetContainerServiceDeploymentsCallable (const GetContainerServiceDeploymentsRequestT &request) const
 
template<typename GetContainerServiceDeploymentsRequestT = Model::GetContainerServiceDeploymentsRequest>
void GetContainerServiceDeploymentsAsync (const GetContainerServiceDeploymentsRequestT &request, const GetContainerServiceDeploymentsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetContainerServiceMetricDataRequestT = Model::GetContainerServiceMetricDataRequest>
Model::GetContainerServiceMetricDataOutcomeCallable GetContainerServiceMetricDataCallable (const GetContainerServiceMetricDataRequestT &request) const
 
template<typename GetContainerServiceMetricDataRequestT = Model::GetContainerServiceMetricDataRequest>
void GetContainerServiceMetricDataAsync (const GetContainerServiceMetricDataRequestT &request, const GetContainerServiceMetricDataResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetContainerServicePowersRequestT = Model::GetContainerServicePowersRequest>
Model::GetContainerServicePowersOutcomeCallable GetContainerServicePowersCallable (const GetContainerServicePowersRequestT &request={}) const
 
template<typename GetContainerServicePowersRequestT = Model::GetContainerServicePowersRequest>
void GetContainerServicePowersAsync (const GetContainerServicePowersResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetContainerServicePowersRequestT &request={}) const
 
 
template<typename GetContainerServicesRequestT = Model::GetContainerServicesRequest>
Model::GetContainerServicesOutcomeCallable GetContainerServicesCallable (const GetContainerServicesRequestT &request={}) const
 
template<typename GetContainerServicesRequestT = Model::GetContainerServicesRequest>
void GetContainerServicesAsync (const GetContainerServicesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetContainerServicesRequestT &request={}) const
 
 
template<typename GetCostEstimateRequestT = Model::GetCostEstimateRequest>
Model::GetCostEstimateOutcomeCallable GetCostEstimateCallable (const GetCostEstimateRequestT &request) const
 
template<typename GetCostEstimateRequestT = Model::GetCostEstimateRequest>
void GetCostEstimateAsync (const GetCostEstimateRequestT &request, const GetCostEstimateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
virtual Model::GetDiskOutcome GetDisk (const Model::GetDiskRequest &request) const
 
template<typename GetDiskRequestT = Model::GetDiskRequest>
Model::GetDiskOutcomeCallable GetDiskCallable (const GetDiskRequestT &request) const
 
template<typename GetDiskRequestT = Model::GetDiskRequest>
void GetDiskAsync (const GetDiskRequestT &request, const GetDiskResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetDiskSnapshotRequestT = Model::GetDiskSnapshotRequest>
Model::GetDiskSnapshotOutcomeCallable GetDiskSnapshotCallable (const GetDiskSnapshotRequestT &request) const
 
template<typename GetDiskSnapshotRequestT = Model::GetDiskSnapshotRequest>
void GetDiskSnapshotAsync (const GetDiskSnapshotRequestT &request, const GetDiskSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetDiskSnapshotsRequestT = Model::GetDiskSnapshotsRequest>
Model::GetDiskSnapshotsOutcomeCallable GetDiskSnapshotsCallable (const GetDiskSnapshotsRequestT &request={}) const
 
template<typename GetDiskSnapshotsRequestT = Model::GetDiskSnapshotsRequest>
void GetDiskSnapshotsAsync (const GetDiskSnapshotsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetDiskSnapshotsRequestT &request={}) const
 
virtual Model::GetDisksOutcome GetDisks (const Model::GetDisksRequest &request={}) const
 
template<typename GetDisksRequestT = Model::GetDisksRequest>
Model::GetDisksOutcomeCallable GetDisksCallable (const GetDisksRequestT &request={}) const
 
template<typename GetDisksRequestT = Model::GetDisksRequest>
void GetDisksAsync (const GetDisksResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetDisksRequestT &request={}) const
 
 
template<typename GetDistributionBundlesRequestT = Model::GetDistributionBundlesRequest>
Model::GetDistributionBundlesOutcomeCallable GetDistributionBundlesCallable (const GetDistributionBundlesRequestT &request={}) const
 
template<typename GetDistributionBundlesRequestT = Model::GetDistributionBundlesRequest>
void GetDistributionBundlesAsync (const GetDistributionBundlesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetDistributionBundlesRequestT &request={}) const
 
 
template<typename GetDistributionLatestCacheResetRequestT = Model::GetDistributionLatestCacheResetRequest>
Model::GetDistributionLatestCacheResetOutcomeCallable GetDistributionLatestCacheResetCallable (const GetDistributionLatestCacheResetRequestT &request={}) const
 
template<typename GetDistributionLatestCacheResetRequestT = Model::GetDistributionLatestCacheResetRequest>
void GetDistributionLatestCacheResetAsync (const GetDistributionLatestCacheResetResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetDistributionLatestCacheResetRequestT &request={}) const
 
 
template<typename GetDistributionMetricDataRequestT = Model::GetDistributionMetricDataRequest>
Model::GetDistributionMetricDataOutcomeCallable GetDistributionMetricDataCallable (const GetDistributionMetricDataRequestT &request) const
 
template<typename GetDistributionMetricDataRequestT = Model::GetDistributionMetricDataRequest>
void GetDistributionMetricDataAsync (const GetDistributionMetricDataRequestT &request, const GetDistributionMetricDataResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetDistributionsRequestT = Model::GetDistributionsRequest>
Model::GetDistributionsOutcomeCallable GetDistributionsCallable (const GetDistributionsRequestT &request={}) const
 
template<typename GetDistributionsRequestT = Model::GetDistributionsRequest>
void GetDistributionsAsync (const GetDistributionsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetDistributionsRequestT &request={}) const
 
 
template<typename GetDomainRequestT = Model::GetDomainRequest>
Model::GetDomainOutcomeCallable GetDomainCallable (const GetDomainRequestT &request) const
 
template<typename GetDomainRequestT = Model::GetDomainRequest>
void GetDomainAsync (const GetDomainRequestT &request, const GetDomainResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetDomainsRequestT = Model::GetDomainsRequest>
Model::GetDomainsOutcomeCallable GetDomainsCallable (const GetDomainsRequestT &request={}) const
 
template<typename GetDomainsRequestT = Model::GetDomainsRequest>
void GetDomainsAsync (const GetDomainsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetDomainsRequestT &request={}) const
 
 
template<typename GetExportSnapshotRecordsRequestT = Model::GetExportSnapshotRecordsRequest>
Model::GetExportSnapshotRecordsOutcomeCallable GetExportSnapshotRecordsCallable (const GetExportSnapshotRecordsRequestT &request={}) const
 
template<typename GetExportSnapshotRecordsRequestT = Model::GetExportSnapshotRecordsRequest>
void GetExportSnapshotRecordsAsync (const GetExportSnapshotRecordsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetExportSnapshotRecordsRequestT &request={}) const
 
 
template<typename GetInstanceRequestT = Model::GetInstanceRequest>
Model::GetInstanceOutcomeCallable GetInstanceCallable (const GetInstanceRequestT &request) const
 
template<typename GetInstanceRequestT = Model::GetInstanceRequest>
void GetInstanceAsync (const GetInstanceRequestT &request, const GetInstanceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetInstanceAccessDetailsRequestT = Model::GetInstanceAccessDetailsRequest>
Model::GetInstanceAccessDetailsOutcomeCallable GetInstanceAccessDetailsCallable (const GetInstanceAccessDetailsRequestT &request) const
 
template<typename GetInstanceAccessDetailsRequestT = Model::GetInstanceAccessDetailsRequest>
void GetInstanceAccessDetailsAsync (const GetInstanceAccessDetailsRequestT &request, const GetInstanceAccessDetailsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetInstanceMetricDataRequestT = Model::GetInstanceMetricDataRequest>
Model::GetInstanceMetricDataOutcomeCallable GetInstanceMetricDataCallable (const GetInstanceMetricDataRequestT &request) const
 
template<typename GetInstanceMetricDataRequestT = Model::GetInstanceMetricDataRequest>
void GetInstanceMetricDataAsync (const GetInstanceMetricDataRequestT &request, const GetInstanceMetricDataResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetInstancePortStatesRequestT = Model::GetInstancePortStatesRequest>
Model::GetInstancePortStatesOutcomeCallable GetInstancePortStatesCallable (const GetInstancePortStatesRequestT &request) const
 
template<typename GetInstancePortStatesRequestT = Model::GetInstancePortStatesRequest>
void GetInstancePortStatesAsync (const GetInstancePortStatesRequestT &request, const GetInstancePortStatesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetInstanceSnapshotRequestT = Model::GetInstanceSnapshotRequest>
Model::GetInstanceSnapshotOutcomeCallable GetInstanceSnapshotCallable (const GetInstanceSnapshotRequestT &request) const
 
template<typename GetInstanceSnapshotRequestT = Model::GetInstanceSnapshotRequest>
void GetInstanceSnapshotAsync (const GetInstanceSnapshotRequestT &request, const GetInstanceSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetInstanceSnapshotsRequestT = Model::GetInstanceSnapshotsRequest>
Model::GetInstanceSnapshotsOutcomeCallable GetInstanceSnapshotsCallable (const GetInstanceSnapshotsRequestT &request={}) const
 
template<typename GetInstanceSnapshotsRequestT = Model::GetInstanceSnapshotsRequest>
void GetInstanceSnapshotsAsync (const GetInstanceSnapshotsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetInstanceSnapshotsRequestT &request={}) const
 
 
template<typename GetInstanceStateRequestT = Model::GetInstanceStateRequest>
Model::GetInstanceStateOutcomeCallable GetInstanceStateCallable (const GetInstanceStateRequestT &request) const
 
template<typename GetInstanceStateRequestT = Model::GetInstanceStateRequest>
void GetInstanceStateAsync (const GetInstanceStateRequestT &request, const GetInstanceStateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetInstancesRequestT = Model::GetInstancesRequest>
Model::GetInstancesOutcomeCallable GetInstancesCallable (const GetInstancesRequestT &request={}) const
 
template<typename GetInstancesRequestT = Model::GetInstancesRequest>
void GetInstancesAsync (const GetInstancesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetInstancesRequestT &request={}) const
 
 
template<typename GetKeyPairRequestT = Model::GetKeyPairRequest>
Model::GetKeyPairOutcomeCallable GetKeyPairCallable (const GetKeyPairRequestT &request) const
 
template<typename GetKeyPairRequestT = Model::GetKeyPairRequest>
void GetKeyPairAsync (const GetKeyPairRequestT &request, const GetKeyPairResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetKeyPairsRequestT = Model::GetKeyPairsRequest>
Model::GetKeyPairsOutcomeCallable GetKeyPairsCallable (const GetKeyPairsRequestT &request={}) const
 
template<typename GetKeyPairsRequestT = Model::GetKeyPairsRequest>
void GetKeyPairsAsync (const GetKeyPairsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetKeyPairsRequestT &request={}) const
 
 
template<typename GetLoadBalancerRequestT = Model::GetLoadBalancerRequest>
Model::GetLoadBalancerOutcomeCallable GetLoadBalancerCallable (const GetLoadBalancerRequestT &request) const
 
template<typename GetLoadBalancerRequestT = Model::GetLoadBalancerRequest>
void GetLoadBalancerAsync (const GetLoadBalancerRequestT &request, const GetLoadBalancerResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetLoadBalancerMetricDataRequestT = Model::GetLoadBalancerMetricDataRequest>
Model::GetLoadBalancerMetricDataOutcomeCallable GetLoadBalancerMetricDataCallable (const GetLoadBalancerMetricDataRequestT &request) const
 
template<typename GetLoadBalancerMetricDataRequestT = Model::GetLoadBalancerMetricDataRequest>
void GetLoadBalancerMetricDataAsync (const GetLoadBalancerMetricDataRequestT &request, const GetLoadBalancerMetricDataResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetLoadBalancerTlsCertificatesRequestT = Model::GetLoadBalancerTlsCertificatesRequest>
Model::GetLoadBalancerTlsCertificatesOutcomeCallable GetLoadBalancerTlsCertificatesCallable (const GetLoadBalancerTlsCertificatesRequestT &request) const
 
template<typename GetLoadBalancerTlsCertificatesRequestT = Model::GetLoadBalancerTlsCertificatesRequest>
void GetLoadBalancerTlsCertificatesAsync (const GetLoadBalancerTlsCertificatesRequestT &request, const GetLoadBalancerTlsCertificatesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetLoadBalancerTlsPoliciesRequestT = Model::GetLoadBalancerTlsPoliciesRequest>
Model::GetLoadBalancerTlsPoliciesOutcomeCallable GetLoadBalancerTlsPoliciesCallable (const GetLoadBalancerTlsPoliciesRequestT &request={}) const
 
template<typename GetLoadBalancerTlsPoliciesRequestT = Model::GetLoadBalancerTlsPoliciesRequest>
void GetLoadBalancerTlsPoliciesAsync (const GetLoadBalancerTlsPoliciesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetLoadBalancerTlsPoliciesRequestT &request={}) const
 
 
template<typename GetLoadBalancersRequestT = Model::GetLoadBalancersRequest>
Model::GetLoadBalancersOutcomeCallable GetLoadBalancersCallable (const GetLoadBalancersRequestT &request={}) const
 
template<typename GetLoadBalancersRequestT = Model::GetLoadBalancersRequest>
void GetLoadBalancersAsync (const GetLoadBalancersResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetLoadBalancersRequestT &request={}) const
 
 
template<typename GetOperationRequestT = Model::GetOperationRequest>
Model::GetOperationOutcomeCallable GetOperationCallable (const GetOperationRequestT &request) const
 
template<typename GetOperationRequestT = Model::GetOperationRequest>
void GetOperationAsync (const GetOperationRequestT &request, const GetOperationResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetOperationsRequestT = Model::GetOperationsRequest>
Model::GetOperationsOutcomeCallable GetOperationsCallable (const GetOperationsRequestT &request={}) const
 
template<typename GetOperationsRequestT = Model::GetOperationsRequest>
void GetOperationsAsync (const GetOperationsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetOperationsRequestT &request={}) const
 
 
template<typename GetOperationsForResourceRequestT = Model::GetOperationsForResourceRequest>
Model::GetOperationsForResourceOutcomeCallable GetOperationsForResourceCallable (const GetOperationsForResourceRequestT &request) const
 
template<typename GetOperationsForResourceRequestT = Model::GetOperationsForResourceRequest>
void GetOperationsForResourceAsync (const GetOperationsForResourceRequestT &request, const GetOperationsForResourceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetRegionsRequestT = Model::GetRegionsRequest>
Model::GetRegionsOutcomeCallable GetRegionsCallable (const GetRegionsRequestT &request={}) const
 
template<typename GetRegionsRequestT = Model::GetRegionsRequest>
void GetRegionsAsync (const GetRegionsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetRegionsRequestT &request={}) const
 
 
template<typename GetRelationalDatabaseRequestT = Model::GetRelationalDatabaseRequest>
Model::GetRelationalDatabaseOutcomeCallable GetRelationalDatabaseCallable (const GetRelationalDatabaseRequestT &request) const
 
template<typename GetRelationalDatabaseRequestT = Model::GetRelationalDatabaseRequest>
void GetRelationalDatabaseAsync (const GetRelationalDatabaseRequestT &request, const GetRelationalDatabaseResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetRelationalDatabaseBlueprintsRequestT = Model::GetRelationalDatabaseBlueprintsRequest>
Model::GetRelationalDatabaseBlueprintsOutcomeCallable GetRelationalDatabaseBlueprintsCallable (const GetRelationalDatabaseBlueprintsRequestT &request={}) const
 
template<typename GetRelationalDatabaseBlueprintsRequestT = Model::GetRelationalDatabaseBlueprintsRequest>
void GetRelationalDatabaseBlueprintsAsync (const GetRelationalDatabaseBlueprintsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetRelationalDatabaseBlueprintsRequestT &request={}) const
 
 
template<typename GetRelationalDatabaseBundlesRequestT = Model::GetRelationalDatabaseBundlesRequest>
Model::GetRelationalDatabaseBundlesOutcomeCallable GetRelationalDatabaseBundlesCallable (const GetRelationalDatabaseBundlesRequestT &request={}) const
 
template<typename GetRelationalDatabaseBundlesRequestT = Model::GetRelationalDatabaseBundlesRequest>
void GetRelationalDatabaseBundlesAsync (const GetRelationalDatabaseBundlesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetRelationalDatabaseBundlesRequestT &request={}) const
 
 
template<typename GetRelationalDatabaseEventsRequestT = Model::GetRelationalDatabaseEventsRequest>
Model::GetRelationalDatabaseEventsOutcomeCallable GetRelationalDatabaseEventsCallable (const GetRelationalDatabaseEventsRequestT &request) const
 
template<typename GetRelationalDatabaseEventsRequestT = Model::GetRelationalDatabaseEventsRequest>
void GetRelationalDatabaseEventsAsync (const GetRelationalDatabaseEventsRequestT &request, const GetRelationalDatabaseEventsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetRelationalDatabaseLogEventsRequestT = Model::GetRelationalDatabaseLogEventsRequest>
Model::GetRelationalDatabaseLogEventsOutcomeCallable GetRelationalDatabaseLogEventsCallable (const GetRelationalDatabaseLogEventsRequestT &request) const
 
template<typename GetRelationalDatabaseLogEventsRequestT = Model::GetRelationalDatabaseLogEventsRequest>
void GetRelationalDatabaseLogEventsAsync (const GetRelationalDatabaseLogEventsRequestT &request, const GetRelationalDatabaseLogEventsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetRelationalDatabaseLogStreamsRequestT = Model::GetRelationalDatabaseLogStreamsRequest>
Model::GetRelationalDatabaseLogStreamsOutcomeCallable GetRelationalDatabaseLogStreamsCallable (const GetRelationalDatabaseLogStreamsRequestT &request) const
 
template<typename GetRelationalDatabaseLogStreamsRequestT = Model::GetRelationalDatabaseLogStreamsRequest>
void GetRelationalDatabaseLogStreamsAsync (const GetRelationalDatabaseLogStreamsRequestT &request, const GetRelationalDatabaseLogStreamsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetRelationalDatabaseMasterUserPasswordRequestT = Model::GetRelationalDatabaseMasterUserPasswordRequest>
Model::GetRelationalDatabaseMasterUserPasswordOutcomeCallable GetRelationalDatabaseMasterUserPasswordCallable (const GetRelationalDatabaseMasterUserPasswordRequestT &request) const
 
template<typename GetRelationalDatabaseMasterUserPasswordRequestT = Model::GetRelationalDatabaseMasterUserPasswordRequest>
void GetRelationalDatabaseMasterUserPasswordAsync (const GetRelationalDatabaseMasterUserPasswordRequestT &request, const GetRelationalDatabaseMasterUserPasswordResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetRelationalDatabaseMetricDataRequestT = Model::GetRelationalDatabaseMetricDataRequest>
Model::GetRelationalDatabaseMetricDataOutcomeCallable GetRelationalDatabaseMetricDataCallable (const GetRelationalDatabaseMetricDataRequestT &request) const
 
template<typename GetRelationalDatabaseMetricDataRequestT = Model::GetRelationalDatabaseMetricDataRequest>
void GetRelationalDatabaseMetricDataAsync (const GetRelationalDatabaseMetricDataRequestT &request, const GetRelationalDatabaseMetricDataResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetRelationalDatabaseParametersRequestT = Model::GetRelationalDatabaseParametersRequest>
Model::GetRelationalDatabaseParametersOutcomeCallable GetRelationalDatabaseParametersCallable (const GetRelationalDatabaseParametersRequestT &request) const
 
template<typename GetRelationalDatabaseParametersRequestT = Model::GetRelationalDatabaseParametersRequest>
void GetRelationalDatabaseParametersAsync (const GetRelationalDatabaseParametersRequestT &request, const GetRelationalDatabaseParametersResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetRelationalDatabaseSnapshotRequestT = Model::GetRelationalDatabaseSnapshotRequest>
Model::GetRelationalDatabaseSnapshotOutcomeCallable GetRelationalDatabaseSnapshotCallable (const GetRelationalDatabaseSnapshotRequestT &request) const
 
template<typename GetRelationalDatabaseSnapshotRequestT = Model::GetRelationalDatabaseSnapshotRequest>
void GetRelationalDatabaseSnapshotAsync (const GetRelationalDatabaseSnapshotRequestT &request, const GetRelationalDatabaseSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetRelationalDatabaseSnapshotsRequestT = Model::GetRelationalDatabaseSnapshotsRequest>
Model::GetRelationalDatabaseSnapshotsOutcomeCallable GetRelationalDatabaseSnapshotsCallable (const GetRelationalDatabaseSnapshotsRequestT &request={}) const
 
template<typename GetRelationalDatabaseSnapshotsRequestT = Model::GetRelationalDatabaseSnapshotsRequest>
void GetRelationalDatabaseSnapshotsAsync (const GetRelationalDatabaseSnapshotsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetRelationalDatabaseSnapshotsRequestT &request={}) const
 
 
template<typename GetRelationalDatabasesRequestT = Model::GetRelationalDatabasesRequest>
Model::GetRelationalDatabasesOutcomeCallable GetRelationalDatabasesCallable (const GetRelationalDatabasesRequestT &request={}) const
 
template<typename GetRelationalDatabasesRequestT = Model::GetRelationalDatabasesRequest>
void GetRelationalDatabasesAsync (const GetRelationalDatabasesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetRelationalDatabasesRequestT &request={}) const
 
 
template<typename GetSetupHistoryRequestT = Model::GetSetupHistoryRequest>
Model::GetSetupHistoryOutcomeCallable GetSetupHistoryCallable (const GetSetupHistoryRequestT &request) const
 
template<typename GetSetupHistoryRequestT = Model::GetSetupHistoryRequest>
void GetSetupHistoryAsync (const GetSetupHistoryRequestT &request, const GetSetupHistoryResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetStaticIpRequestT = Model::GetStaticIpRequest>
Model::GetStaticIpOutcomeCallable GetStaticIpCallable (const GetStaticIpRequestT &request) const
 
template<typename GetStaticIpRequestT = Model::GetStaticIpRequest>
void GetStaticIpAsync (const GetStaticIpRequestT &request, const GetStaticIpResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetStaticIpsRequestT = Model::GetStaticIpsRequest>
Model::GetStaticIpsOutcomeCallable GetStaticIpsCallable (const GetStaticIpsRequestT &request={}) const
 
template<typename GetStaticIpsRequestT = Model::GetStaticIpsRequest>
void GetStaticIpsAsync (const GetStaticIpsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetStaticIpsRequestT &request={}) const
 
 
template<typename ImportKeyPairRequestT = Model::ImportKeyPairRequest>
Model::ImportKeyPairOutcomeCallable ImportKeyPairCallable (const ImportKeyPairRequestT &request) const
 
template<typename ImportKeyPairRequestT = Model::ImportKeyPairRequest>
void ImportKeyPairAsync (const ImportKeyPairRequestT &request, const ImportKeyPairResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename IsVpcPeeredRequestT = Model::IsVpcPeeredRequest>
Model::IsVpcPeeredOutcomeCallable IsVpcPeeredCallable (const IsVpcPeeredRequestT &request={}) const
 
template<typename IsVpcPeeredRequestT = Model::IsVpcPeeredRequest>
void IsVpcPeeredAsync (const IsVpcPeeredResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const IsVpcPeeredRequestT &request={}) const
 
 
template<typename OpenInstancePublicPortsRequestT = Model::OpenInstancePublicPortsRequest>
Model::OpenInstancePublicPortsOutcomeCallable OpenInstancePublicPortsCallable (const OpenInstancePublicPortsRequestT &request) const
 
template<typename OpenInstancePublicPortsRequestT = Model::OpenInstancePublicPortsRequest>
void OpenInstancePublicPortsAsync (const OpenInstancePublicPortsRequestT &request, const OpenInstancePublicPortsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
virtual Model::PeerVpcOutcome PeerVpc (const Model::PeerVpcRequest &request={}) const
 
template<typename PeerVpcRequestT = Model::PeerVpcRequest>
Model::PeerVpcOutcomeCallable PeerVpcCallable (const PeerVpcRequestT &request={}) const
 
template<typename PeerVpcRequestT = Model::PeerVpcRequest>
void PeerVpcAsync (const PeerVpcResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const PeerVpcRequestT &request={}) const
 
 
template<typename PutAlarmRequestT = Model::PutAlarmRequest>
Model::PutAlarmOutcomeCallable PutAlarmCallable (const PutAlarmRequestT &request) const
 
template<typename PutAlarmRequestT = Model::PutAlarmRequest>
void PutAlarmAsync (const PutAlarmRequestT &request, const PutAlarmResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename PutInstancePublicPortsRequestT = Model::PutInstancePublicPortsRequest>
Model::PutInstancePublicPortsOutcomeCallable PutInstancePublicPortsCallable (const PutInstancePublicPortsRequestT &request) const
 
template<typename PutInstancePublicPortsRequestT = Model::PutInstancePublicPortsRequest>
void PutInstancePublicPortsAsync (const PutInstancePublicPortsRequestT &request, const PutInstancePublicPortsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename RebootInstanceRequestT = Model::RebootInstanceRequest>
Model::RebootInstanceOutcomeCallable RebootInstanceCallable (const RebootInstanceRequestT &request) const
 
template<typename RebootInstanceRequestT = Model::RebootInstanceRequest>
void RebootInstanceAsync (const RebootInstanceRequestT &request, const RebootInstanceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename RebootRelationalDatabaseRequestT = Model::RebootRelationalDatabaseRequest>
Model::RebootRelationalDatabaseOutcomeCallable RebootRelationalDatabaseCallable (const RebootRelationalDatabaseRequestT &request) const
 
template<typename RebootRelationalDatabaseRequestT = Model::RebootRelationalDatabaseRequest>
void RebootRelationalDatabaseAsync (const RebootRelationalDatabaseRequestT &request, const RebootRelationalDatabaseResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename RegisterContainerImageRequestT = Model::RegisterContainerImageRequest>
Model::RegisterContainerImageOutcomeCallable RegisterContainerImageCallable (const RegisterContainerImageRequestT &request) const
 
template<typename RegisterContainerImageRequestT = Model::RegisterContainerImageRequest>
void RegisterContainerImageAsync (const RegisterContainerImageRequestT &request, const RegisterContainerImageResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ReleaseStaticIpRequestT = Model::ReleaseStaticIpRequest>
Model::ReleaseStaticIpOutcomeCallable ReleaseStaticIpCallable (const ReleaseStaticIpRequestT &request) const
 
template<typename ReleaseStaticIpRequestT = Model::ReleaseStaticIpRequest>
void ReleaseStaticIpAsync (const ReleaseStaticIpRequestT &request, const ReleaseStaticIpResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ResetDistributionCacheRequestT = Model::ResetDistributionCacheRequest>
Model::ResetDistributionCacheOutcomeCallable ResetDistributionCacheCallable (const ResetDistributionCacheRequestT &request={}) const
 
template<typename ResetDistributionCacheRequestT = Model::ResetDistributionCacheRequest>
void ResetDistributionCacheAsync (const ResetDistributionCacheResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const ResetDistributionCacheRequestT &request={}) const
 
 
template<typename SendContactMethodVerificationRequestT = Model::SendContactMethodVerificationRequest>
Model::SendContactMethodVerificationOutcomeCallable SendContactMethodVerificationCallable (const SendContactMethodVerificationRequestT &request) const
 
template<typename SendContactMethodVerificationRequestT = Model::SendContactMethodVerificationRequest>
void SendContactMethodVerificationAsync (const SendContactMethodVerificationRequestT &request, const SendContactMethodVerificationResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename SetIpAddressTypeRequestT = Model::SetIpAddressTypeRequest>
Model::SetIpAddressTypeOutcomeCallable SetIpAddressTypeCallable (const SetIpAddressTypeRequestT &request) const
 
template<typename SetIpAddressTypeRequestT = Model::SetIpAddressTypeRequest>
void SetIpAddressTypeAsync (const SetIpAddressTypeRequestT &request, const SetIpAddressTypeResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename SetResourceAccessForBucketRequestT = Model::SetResourceAccessForBucketRequest>
Model::SetResourceAccessForBucketOutcomeCallable SetResourceAccessForBucketCallable (const SetResourceAccessForBucketRequestT &request) const
 
template<typename SetResourceAccessForBucketRequestT = Model::SetResourceAccessForBucketRequest>
void SetResourceAccessForBucketAsync (const SetResourceAccessForBucketRequestT &request, const SetResourceAccessForBucketResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename SetupInstanceHttpsRequestT = Model::SetupInstanceHttpsRequest>
Model::SetupInstanceHttpsOutcomeCallable SetupInstanceHttpsCallable (const SetupInstanceHttpsRequestT &request) const
 
template<typename SetupInstanceHttpsRequestT = Model::SetupInstanceHttpsRequest>
void SetupInstanceHttpsAsync (const SetupInstanceHttpsRequestT &request, const SetupInstanceHttpsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename StartGUISessionRequestT = Model::StartGUISessionRequest>
Model::StartGUISessionOutcomeCallable StartGUISessionCallable (const StartGUISessionRequestT &request) const
 
template<typename StartGUISessionRequestT = Model::StartGUISessionRequest>
void StartGUISessionAsync (const StartGUISessionRequestT &request, const StartGUISessionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename StartInstanceRequestT = Model::StartInstanceRequest>
Model::StartInstanceOutcomeCallable StartInstanceCallable (const StartInstanceRequestT &request) const
 
template<typename StartInstanceRequestT = Model::StartInstanceRequest>
void StartInstanceAsync (const StartInstanceRequestT &request, const StartInstanceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename StartRelationalDatabaseRequestT = Model::StartRelationalDatabaseRequest>
Model::StartRelationalDatabaseOutcomeCallable StartRelationalDatabaseCallable (const StartRelationalDatabaseRequestT &request) const
 
template<typename StartRelationalDatabaseRequestT = Model::StartRelationalDatabaseRequest>
void StartRelationalDatabaseAsync (const StartRelationalDatabaseRequestT &request, const StartRelationalDatabaseResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename StopGUISessionRequestT = Model::StopGUISessionRequest>
Model::StopGUISessionOutcomeCallable StopGUISessionCallable (const StopGUISessionRequestT &request) const
 
template<typename StopGUISessionRequestT = Model::StopGUISessionRequest>
void StopGUISessionAsync (const StopGUISessionRequestT &request, const StopGUISessionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename StopInstanceRequestT = Model::StopInstanceRequest>
Model::StopInstanceOutcomeCallable StopInstanceCallable (const StopInstanceRequestT &request) const
 
template<typename StopInstanceRequestT = Model::StopInstanceRequest>
void StopInstanceAsync (const StopInstanceRequestT &request, const StopInstanceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename StopRelationalDatabaseRequestT = Model::StopRelationalDatabaseRequest>
Model::StopRelationalDatabaseOutcomeCallable StopRelationalDatabaseCallable (const StopRelationalDatabaseRequestT &request) const
 
template<typename StopRelationalDatabaseRequestT = Model::StopRelationalDatabaseRequest>
void StopRelationalDatabaseAsync (const StopRelationalDatabaseRequestT &request, const StopRelationalDatabaseResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename TagResourceRequestT = Model::TagResourceRequest>
Model::TagResourceOutcomeCallable TagResourceCallable (const TagResourceRequestT &request) const
 
template<typename TagResourceRequestT = Model::TagResourceRequest>
void TagResourceAsync (const TagResourceRequestT &request, const TagResourceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename TestAlarmRequestT = Model::TestAlarmRequest>
Model::TestAlarmOutcomeCallable TestAlarmCallable (const TestAlarmRequestT &request) const
 
template<typename TestAlarmRequestT = Model::TestAlarmRequest>
void TestAlarmAsync (const TestAlarmRequestT &request, const TestAlarmResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
virtual Model::UnpeerVpcOutcome UnpeerVpc (const Model::UnpeerVpcRequest &request={}) const
 
template<typename UnpeerVpcRequestT = Model::UnpeerVpcRequest>
Model::UnpeerVpcOutcomeCallable UnpeerVpcCallable (const UnpeerVpcRequestT &request={}) const
 
template<typename UnpeerVpcRequestT = Model::UnpeerVpcRequest>
void UnpeerVpcAsync (const UnpeerVpcResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const UnpeerVpcRequestT &request={}) const
 
 
template<typename UntagResourceRequestT = Model::UntagResourceRequest>
Model::UntagResourceOutcomeCallable UntagResourceCallable (const UntagResourceRequestT &request) const
 
template<typename UntagResourceRequestT = Model::UntagResourceRequest>
void UntagResourceAsync (const UntagResourceRequestT &request, const UntagResourceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateBucketRequestT = Model::UpdateBucketRequest>
Model::UpdateBucketOutcomeCallable UpdateBucketCallable (const UpdateBucketRequestT &request) const
 
template<typename UpdateBucketRequestT = Model::UpdateBucketRequest>
void UpdateBucketAsync (const UpdateBucketRequestT &request, const UpdateBucketResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateBucketBundleRequestT = Model::UpdateBucketBundleRequest>
Model::UpdateBucketBundleOutcomeCallable UpdateBucketBundleCallable (const UpdateBucketBundleRequestT &request) const
 
template<typename UpdateBucketBundleRequestT = Model::UpdateBucketBundleRequest>
void UpdateBucketBundleAsync (const UpdateBucketBundleRequestT &request, const UpdateBucketBundleResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateContainerServiceRequestT = Model::UpdateContainerServiceRequest>
Model::UpdateContainerServiceOutcomeCallable UpdateContainerServiceCallable (const UpdateContainerServiceRequestT &request) const
 
template<typename UpdateContainerServiceRequestT = Model::UpdateContainerServiceRequest>
void UpdateContainerServiceAsync (const UpdateContainerServiceRequestT &request, const UpdateContainerServiceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateDistributionRequestT = Model::UpdateDistributionRequest>
Model::UpdateDistributionOutcomeCallable UpdateDistributionCallable (const UpdateDistributionRequestT &request) const
 
template<typename UpdateDistributionRequestT = Model::UpdateDistributionRequest>
void UpdateDistributionAsync (const UpdateDistributionRequestT &request, const UpdateDistributionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateDistributionBundleRequestT = Model::UpdateDistributionBundleRequest>
Model::UpdateDistributionBundleOutcomeCallable UpdateDistributionBundleCallable (const UpdateDistributionBundleRequestT &request={}) const
 
template<typename UpdateDistributionBundleRequestT = Model::UpdateDistributionBundleRequest>
void UpdateDistributionBundleAsync (const UpdateDistributionBundleResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const UpdateDistributionBundleRequestT &request={}) const
 
 
template<typename UpdateDomainEntryRequestT = Model::UpdateDomainEntryRequest>
Model::UpdateDomainEntryOutcomeCallable UpdateDomainEntryCallable (const UpdateDomainEntryRequestT &request) const
 
template<typename UpdateDomainEntryRequestT = Model::UpdateDomainEntryRequest>
void UpdateDomainEntryAsync (const UpdateDomainEntryRequestT &request, const UpdateDomainEntryResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateInstanceMetadataOptionsRequestT = Model::UpdateInstanceMetadataOptionsRequest>
Model::UpdateInstanceMetadataOptionsOutcomeCallable UpdateInstanceMetadataOptionsCallable (const UpdateInstanceMetadataOptionsRequestT &request) const
 
template<typename UpdateInstanceMetadataOptionsRequestT = Model::UpdateInstanceMetadataOptionsRequest>
void UpdateInstanceMetadataOptionsAsync (const UpdateInstanceMetadataOptionsRequestT &request, const UpdateInstanceMetadataOptionsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateLoadBalancerAttributeRequestT = Model::UpdateLoadBalancerAttributeRequest>
Model::UpdateLoadBalancerAttributeOutcomeCallable UpdateLoadBalancerAttributeCallable (const UpdateLoadBalancerAttributeRequestT &request) const
 
template<typename UpdateLoadBalancerAttributeRequestT = Model::UpdateLoadBalancerAttributeRequest>
void UpdateLoadBalancerAttributeAsync (const UpdateLoadBalancerAttributeRequestT &request, const UpdateLoadBalancerAttributeResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateRelationalDatabaseRequestT = Model::UpdateRelationalDatabaseRequest>
Model::UpdateRelationalDatabaseOutcomeCallable UpdateRelationalDatabaseCallable (const UpdateRelationalDatabaseRequestT &request) const
 
template<typename UpdateRelationalDatabaseRequestT = Model::UpdateRelationalDatabaseRequest>
void UpdateRelationalDatabaseAsync (const UpdateRelationalDatabaseRequestT &request, const UpdateRelationalDatabaseResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateRelationalDatabaseParametersRequestT = Model::UpdateRelationalDatabaseParametersRequest>
Model::UpdateRelationalDatabaseParametersOutcomeCallable UpdateRelationalDatabaseParametersCallable (const UpdateRelationalDatabaseParametersRequestT &request) const
 
template<typename UpdateRelationalDatabaseParametersRequestT = Model::UpdateRelationalDatabaseParametersRequest>
void UpdateRelationalDatabaseParametersAsync (const UpdateRelationalDatabaseParametersRequestT &request, const UpdateRelationalDatabaseParametersResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
void OverrideEndpoint (const Aws::String &endpoint)
 
 

Public Member Functions inherited from Aws::Client::AWSJsonClient

 AWSJsonClient (const Aws::Client::ClientConfiguration &configuration, const std::shared_ptr< Aws::Client::AWSAuthSigner > &signer, const std::shared_ptr< AWSErrorMarshaller > &errorMarshaller)
 
 AWSJsonClient (const Aws::Client::ClientConfiguration &configuration, const std::shared_ptr< Aws::Auth::AWSAuthSignerProvider > &signerProvider, const std::shared_ptr< AWSErrorMarshaller > &errorMarshaller)
 
virtual ~AWSJsonClient ()=default
 

Public Member Functions inherited from Aws::Client::AWSClient

 AWSClient (const Aws::Client::ClientConfiguration &configuration, const std::shared_ptr< Aws::Client::AWSAuthSigner > &signer, const std::shared_ptr< AWSErrorMarshaller > &errorMarshaller)
 
 AWSClient (const Aws::Client::ClientConfiguration &configuration, const std::shared_ptr< Aws::Auth::AWSAuthSignerProvider > &signerProvider, const std::shared_ptr< AWSErrorMarshaller > &errorMarshaller)
 
virtual ~AWSClient ()
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const Aws::Http::HeaderValueCollection &customizedHeaders, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const Aws::Http::HeaderValueCollection &customizedHeaders, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, const Aws::Http::HeaderValueCollection &customizedHeaders, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, const char *signerName, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, const char *signerName, const Aws::Http::HeaderValueCollection &customizedHeaders, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::Endpoint::AWSEndpoint &endpoint, Aws::Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const Aws::Http::HeaderValueCollection &customizedHeaders={}, uint64_t expirationInSeconds=0, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::AmazonWebServiceRequest &request, const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const Aws::Http::QueryStringParameterCollection &extraParams=Aws::Http::QueryStringParameterCollection(), long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::AmazonWebServiceRequest &request, const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, const char *signerName, const Aws::Http::QueryStringParameterCollection &extraParams=Aws::Http::QueryStringParameterCollection(), long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::AmazonWebServiceRequest &request, const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, const Aws::Http::QueryStringParameterCollection &extraParams=Aws::Http::QueryStringParameterCollection(), long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::AmazonWebServiceRequest &request, const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const Aws::Http::QueryStringParameterCollection &extraParams=Aws::Http::QueryStringParameterCollection(), long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
const std::shared_ptr< Aws::Http::HttpClient > & GetHttpClient () const
 
 
 
virtual const char * GetServiceClientName () const
 
virtual void SetServiceClientName (const Aws::String &name)
 
void AppendToUserAgent (const Aws::String &valueToAppend)
 
 
 
 
 
void SubmitAsync (OperationFuncT operationFunc, const RequestT &request, const HandlerT &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
void SubmitAsync (OperationFuncT operationFunc, RequestT &request, const HandlerT &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
void SubmitAsync (OperationFuncT operationFunc, const HandlerT &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
auto SubmitCallable (OperationFuncT operationFunc, const RequestT &request) const -> std::future< decltype((static_cast< const AwsServiceClientT * >(nullptr) -> *operationFunc)(request))>
 
auto SubmitCallable (OperationFuncT operationFunc, RequestT &request) const -> std::future< decltype((static_cast< const AwsServiceClientT * >(nullptr) -> *operationFunc)(request))>
 
auto SubmitCallable (OperationFuncT operationFunc) const -> std::future< decltype((static_cast< const AwsServiceClientT * >(nullptr) -> *operationFunc)())>
 

Static Public Member Functions

static const char * GetServiceName ()
 
static const char * GetAllocationTag ()
 

Static Public Member Functions inherited from Aws::Client::ClientWithAsyncTemplateMethods< LightsailClient >

static void ShutdownSdkClient (void *pThis, int64_t timeoutMs=-1)
 

Friends

 

Additional Inherited Members

Protected Member Functions inherited from Aws::Client::AWSJsonClient

virtual AWSError< CoreErrorsBuildAWSError (const std::shared_ptr< Aws::Http::HttpResponse > &response) const override
 
JsonOutcome MakeRequest (const Aws::AmazonWebServiceRequest &request, const Aws::Endpoint::AWSEndpoint &endpoint, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
JsonOutcome MakeRequest (const Aws::Endpoint::AWSEndpoint &endpoint, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
JsonOutcome MakeRequest (const Aws::Http::URI &uri, const Aws::AmazonWebServiceRequest &request, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
JsonOutcome MakeRequest (const Aws::Http::URI &uri, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *requestName="", const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
JsonOutcome MakeEventStreamRequest (std::shared_ptr< Aws::Http::HttpRequest > &request) const
 

Protected Member Functions inherited from Aws::Client::AWSClient

HttpResponseOutcome AttemptExhaustively (const Aws::Http::URI &uri, const Aws::AmazonWebServiceRequest &request, Http::HttpMethod httpMethod, const char *signerName, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
HttpResponseOutcome AttemptExhaustively (const Aws::Http::URI &uri, Http::HttpMethod httpMethod, const char *signerName, const char *requestName="", const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
HttpResponseOutcome AttemptOneRequest (const std::shared_ptr< Http::HttpRequest > &httpRequest, const Aws::AmazonWebServiceRequest &request, const char *signerName, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
HttpResponseOutcome AttemptOneRequest (const std::shared_ptr< Http::HttpRequest > &httpRequest, const char *signerName, const char *requestName="", const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
StreamOutcome MakeRequestWithUnparsedResponse (const Aws::Http::URI &uri, const Aws::AmazonWebServiceRequest &request, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
StreamOutcome MakeRequestWithUnparsedResponse (const Aws::Http::URI &uri, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *requestName="", const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
StreamOutcome MakeRequestWithUnparsedResponse (const Aws::AmazonWebServiceRequest &request, const Aws::Endpoint::AWSEndpoint &endpoint, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
virtual void BuildHttpRequest (const Aws::AmazonWebServiceRequest &request, const std::shared_ptr< Aws::Http::HttpRequest > &httpRequest) const
 
const std::shared_ptr< AWSErrorMarshaller > & GetErrorMarshaller () const
 
Aws::Client::AWSAuthSignerGetSignerByName (const char *name) const
 
 
std::shared_ptr< Aws::Http::HttpRequestBuildAndSignHttpRequest (const Aws::Http::URI &uri, const Aws::AmazonWebServiceRequest &request, Http::HttpMethod method, const char *signerName) const
 
std::shared_ptr< Aws::Http::HttpResponseMakeHttpRequest (std::shared_ptr< Aws::Http::HttpRequest > &request) const
 

Static Protected Member Functions inherited from Aws::Client::AWSClient

static void AppendRecursionDetectionHeader (std::shared_ptr< Aws::Http::HttpRequest > ioRequest)
 
 
static bool DoesResponseGenerateError (const std::shared_ptr< Aws::Http::HttpResponse > &response)
 

Protected Attributes inherited from Aws::Client::AWSClient

 
 
 
std::atomic< bool > m_isInitialized
 
std::atomic< size_t > m_operationsProcessed
 
std::condition_variable m_shutdownSignal
 
std::mutex m_shutdownMutex
 

Detailed Description

Amazon Lightsail is the easiest way to get started with Amazon Web Services (Amazon Web Services) for developers who need to build websites or web applications. It includes everything you need to launch your project quickly - instances (virtual private servers), container services, storage buckets, managed databases, SSD-based block storage, static IP addresses, load balancers, content delivery network (CDN) distributions, DNS management of registered domains, and resource snapshots (backups) - for a low, predictable monthly price.

You can manage your Lightsail resources using the Lightsail console, Lightsail API, Command Line Interface (CLI), or SDKs. For more information about Lightsail concepts and tasks, see the Amazon Lightsail Developer Guide.

This API Reference provides detailed information about the actions, data types, parameters, and errors of the Lightsail service. For more information about the supported Amazon Web Services Regions, endpoints, and service quotas of the Lightsail service, see Amazon Lightsail Endpoints and Quotas in the Amazon Web Services General Reference.

Definition at line 38 of file LightsailClient.h.

Member Typedef Documentation

◆ BASECLASS

Definition at line 41 of file LightsailClient.h.

◆ ClientConfigurationType

Definition at line 45 of file LightsailClient.h.

◆ EndpointProviderType

Definition at line 46 of file LightsailClient.h.

Constructor & Destructor Documentation

◆ LightsailClient() [1/6]

Aws::Lightsail::LightsailClient::LightsailClient ( const Aws::Lightsail::LightsailClientConfiguration clientConfiguration = Aws::Lightsail::LightsailClientConfiguration(),
std::shared_ptr< LightsailEndpointProviderBase endpointProvider = nullptr 
)

Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config is not specified, it will be initialized to default values.

◆ LightsailClient() [2/6]

Aws::Lightsail::LightsailClient::LightsailClient ( const Aws::Auth::AWSCredentials credentials,
std::shared_ptr< LightsailEndpointProviderBase endpointProvider = nullptr,
const Aws::Lightsail::LightsailClientConfiguration clientConfiguration = Aws::Lightsail::LightsailClientConfiguration() 
)

Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config is not specified, it will be initialized to default values.

◆ LightsailClient() [3/6]

Aws::Lightsail::LightsailClient::LightsailClient ( const std::shared_ptr< Aws::Auth::AWSCredentialsProvider > &  credentialsProvider,
std::shared_ptr< LightsailEndpointProviderBase endpointProvider = nullptr,
const Aws::Lightsail::LightsailClientConfiguration clientConfiguration = Aws::Lightsail::LightsailClientConfiguration() 
)

Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, the default http client factory will be used

◆ LightsailClient() [4/6]

Aws::Lightsail::LightsailClient::LightsailClient ( const Aws::Client::ClientConfiguration clientConfiguration)

Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config is not specified, it will be initialized to default values.

◆ LightsailClient() [5/6]

Aws::Lightsail::LightsailClient::LightsailClient ( const Aws::Auth::AWSCredentials credentials,
const Aws::Client::ClientConfiguration clientConfiguration 
)

Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config is not specified, it will be initialized to default values.

◆ LightsailClient() [6/6]

Aws::Lightsail::LightsailClient::LightsailClient ( const std::shared_ptr< Aws::Auth::AWSCredentialsProvider > &  credentialsProvider,
const Aws::Client::ClientConfiguration clientConfiguration 
)

Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, the default http client factory will be used

◆ ~LightsailClient()

virtual Aws::Lightsail::LightsailClient::~LightsailClient ( )
virtual

Member Function Documentation

◆ accessEndpointProvider()

std::shared_ptr< LightsailEndpointProviderBase > & Aws::Lightsail::LightsailClient::accessEndpointProvider ( )

◆ AllocateStaticIp()

virtual Model::AllocateStaticIpOutcome Aws::Lightsail::LightsailClient::AllocateStaticIp ( const Model::AllocateStaticIpRequest request) const
virtual

Allocates a static IP address.

See Also:

AWS API Reference

◆ AllocateStaticIpAsync()

template<typename AllocateStaticIpRequestT = Model::AllocateStaticIpRequest>
void Aws::Lightsail::LightsailClient::AllocateStaticIpAsync ( const AllocateStaticIpRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AllocateStaticIp that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 116 of file LightsailClient.h.

◆ AllocateStaticIpCallable()

template<typename AllocateStaticIpRequestT = Model::AllocateStaticIpRequest>
Model::AllocateStaticIpOutcomeCallable Aws::Lightsail::LightsailClient::AllocateStaticIpCallable ( const AllocateStaticIpRequestT &  request) const
inline

A Callable wrapper for AllocateStaticIp that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 107 of file LightsailClient.h.

◆ AttachCertificateToDistribution()

virtual Model::AttachCertificateToDistributionOutcome Aws::Lightsail::LightsailClient::AttachCertificateToDistribution ( const Model::AttachCertificateToDistributionRequest request) const
virtual

Attaches an SSL/TLS certificate to your Amazon Lightsail content delivery network (CDN) distribution.

After the certificate is attached, your distribution accepts HTTPS traffic for all of the domains that are associated with the certificate.

Use the CreateCertificate action to create a certificate that you can attach to your distribution.

Only certificates created in the us-east-1 Amazon Web Services Region can be attached to Lightsail distributions. Lightsail distributions are global resources that can reference an origin in any Amazon Web Services Region, and distribute its content globally. However, all distributions are located in the us-east-1 Region.

See Also:

AWS API Reference

◆ AttachCertificateToDistributionAsync()

template<typename AttachCertificateToDistributionRequestT = Model::AttachCertificateToDistributionRequest>
void Aws::Lightsail::LightsailClient::AttachCertificateToDistributionAsync ( const AttachCertificateToDistributionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AttachCertificateToDistribution that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 150 of file LightsailClient.h.

◆ AttachCertificateToDistributionCallable()

template<typename AttachCertificateToDistributionRequestT = Model::AttachCertificateToDistributionRequest>
Model::AttachCertificateToDistributionOutcomeCallable Aws::Lightsail::LightsailClient::AttachCertificateToDistributionCallable ( const AttachCertificateToDistributionRequestT &  request) const
inline

A Callable wrapper for AttachCertificateToDistribution that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 141 of file LightsailClient.h.

◆ AttachDisk()

virtual Model::AttachDiskOutcome Aws::Lightsail::LightsailClient::AttachDisk ( const Model::AttachDiskRequest request) const
virtual

Attaches a block storage disk to a running or stopped Lightsail instance and exposes it to the instance with the specified disk name.

The attach disk operation supports tag-based access control via resource tags applied to the resource identified by disk name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ AttachDiskAsync()

template<typename AttachDiskRequestT = Model::AttachDiskRequest>
void Aws::Lightsail::LightsailClient::AttachDiskAsync ( const AttachDiskRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AttachDisk that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 181 of file LightsailClient.h.

◆ AttachDiskCallable()

template<typename AttachDiskRequestT = Model::AttachDiskRequest>
Model::AttachDiskOutcomeCallable Aws::Lightsail::LightsailClient::AttachDiskCallable ( const AttachDiskRequestT &  request) const
inline

A Callable wrapper for AttachDisk that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 172 of file LightsailClient.h.

◆ AttachInstancesToLoadBalancer()

virtual Model::AttachInstancesToLoadBalancerOutcome Aws::Lightsail::LightsailClient::AttachInstancesToLoadBalancer ( const Model::AttachInstancesToLoadBalancerRequest request) const
virtual

Attaches one or more Lightsail instances to a load balancer.

After some time, the instances are attached to the load balancer and the health check status is available.

The attach instances to load balancer operation supports tag-based access control via resource tags applied to the resource identified by load balancer name. For more information, see the Lightsail Developer Guide.

See Also:

AWS API Reference

◆ AttachInstancesToLoadBalancerAsync()

template<typename AttachInstancesToLoadBalancerRequestT = Model::AttachInstancesToLoadBalancerRequest>
void Aws::Lightsail::LightsailClient::AttachInstancesToLoadBalancerAsync ( const AttachInstancesToLoadBalancerRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AttachInstancesToLoadBalancer that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 213 of file LightsailClient.h.

◆ AttachInstancesToLoadBalancerCallable()

template<typename AttachInstancesToLoadBalancerRequestT = Model::AttachInstancesToLoadBalancerRequest>
Model::AttachInstancesToLoadBalancerOutcomeCallable Aws::Lightsail::LightsailClient::AttachInstancesToLoadBalancerCallable ( const AttachInstancesToLoadBalancerRequestT &  request) const
inline

A Callable wrapper for AttachInstancesToLoadBalancer that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 204 of file LightsailClient.h.

◆ AttachLoadBalancerTlsCertificate()

virtual Model::AttachLoadBalancerTlsCertificateOutcome Aws::Lightsail::LightsailClient::AttachLoadBalancerTlsCertificate ( const Model::AttachLoadBalancerTlsCertificateRequest request) const
virtual

Attaches a Transport Layer Security (TLS) certificate to your load balancer. TLS is just an updated, more secure version of Secure Socket Layer (SSL).

Once you create and validate your certificate, you can attach it to your load balancer. You can also use this API to rotate the certificates on your account. Use the AttachLoadBalancerTlsCertificate action with the non-attached certificate, and it will replace the existing one and become the attached certificate.

The AttachLoadBalancerTlsCertificate operation supports tag-based access control via resource tags applied to the resource identified by load balancer name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ AttachLoadBalancerTlsCertificateAsync()

template<typename AttachLoadBalancerTlsCertificateRequestT = Model::AttachLoadBalancerTlsCertificateRequest>
void Aws::Lightsail::LightsailClient::AttachLoadBalancerTlsCertificateAsync ( const AttachLoadBalancerTlsCertificateRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AttachLoadBalancerTlsCertificate that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 249 of file LightsailClient.h.

◆ AttachLoadBalancerTlsCertificateCallable()

template<typename AttachLoadBalancerTlsCertificateRequestT = Model::AttachLoadBalancerTlsCertificateRequest>
Model::AttachLoadBalancerTlsCertificateOutcomeCallable Aws::Lightsail::LightsailClient::AttachLoadBalancerTlsCertificateCallable ( const AttachLoadBalancerTlsCertificateRequestT &  request) const
inline

A Callable wrapper for AttachLoadBalancerTlsCertificate that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 240 of file LightsailClient.h.

◆ AttachStaticIp()

virtual Model::AttachStaticIpOutcome Aws::Lightsail::LightsailClient::AttachStaticIp ( const Model::AttachStaticIpRequest request) const
virtual

Attaches a static IP address to a specific Amazon Lightsail instance.

See Also:

AWS API Reference

◆ AttachStaticIpAsync()

template<typename AttachStaticIpRequestT = Model::AttachStaticIpRequest>
void Aws::Lightsail::LightsailClient::AttachStaticIpAsync ( const AttachStaticIpRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AttachStaticIp that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 275 of file LightsailClient.h.

◆ AttachStaticIpCallable()

template<typename AttachStaticIpRequestT = Model::AttachStaticIpRequest>
Model::AttachStaticIpOutcomeCallable Aws::Lightsail::LightsailClient::AttachStaticIpCallable ( const AttachStaticIpRequestT &  request) const
inline

A Callable wrapper for AttachStaticIp that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 266 of file LightsailClient.h.

◆ CloseInstancePublicPorts()

virtual Model::CloseInstancePublicPortsOutcome Aws::Lightsail::LightsailClient::CloseInstancePublicPorts ( const Model::CloseInstancePublicPortsRequest request) const
virtual

Closes ports for a specific Amazon Lightsail instance.

The CloseInstancePublicPorts action supports tag-based access control via resource tags applied to the resource identified by instanceName. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CloseInstancePublicPortsAsync()

template<typename CloseInstancePublicPortsRequestT = Model::CloseInstancePublicPortsRequest>
void Aws::Lightsail::LightsailClient::CloseInstancePublicPortsAsync ( const CloseInstancePublicPortsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CloseInstancePublicPorts that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 305 of file LightsailClient.h.

◆ CloseInstancePublicPortsCallable()

template<typename CloseInstancePublicPortsRequestT = Model::CloseInstancePublicPortsRequest>
Model::CloseInstancePublicPortsOutcomeCallable Aws::Lightsail::LightsailClient::CloseInstancePublicPortsCallable ( const CloseInstancePublicPortsRequestT &  request) const
inline

A Callable wrapper for CloseInstancePublicPorts that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 296 of file LightsailClient.h.

◆ CopySnapshot()

virtual Model::CopySnapshotOutcome Aws::Lightsail::LightsailClient::CopySnapshot ( const Model::CopySnapshotRequest request) const
virtual

Copies a manual snapshot of an instance or disk as another manual snapshot, or copies an automatic snapshot of an instance or disk as a manual snapshot. This operation can also be used to copy a manual or automatic snapshot of an instance or a disk from one Amazon Web Services Region to another in Amazon Lightsail.

When copying a manual snapshot, be sure to define the source region, source snapshot name, and target snapshot name parameters.

When copying an automatic snapshot, be sure to define the source region, source resource name, target snapshot name, and either the restore date or the use latest restorable auto snapshot parameters.

See Also:

AWS API Reference

◆ CopySnapshotAsync()

template<typename CopySnapshotRequestT = Model::CopySnapshotRequest>
void Aws::Lightsail::LightsailClient::CopySnapshotAsync ( const CopySnapshotRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CopySnapshot that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 340 of file LightsailClient.h.

◆ CopySnapshotCallable()

template<typename CopySnapshotRequestT = Model::CopySnapshotRequest>
Model::CopySnapshotOutcomeCallable Aws::Lightsail::LightsailClient::CopySnapshotCallable ( const CopySnapshotRequestT &  request) const
inline

A Callable wrapper for CopySnapshot that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 331 of file LightsailClient.h.

◆ CreateBucket()

virtual Model::CreateBucketOutcome Aws::Lightsail::LightsailClient::CreateBucket ( const Model::CreateBucketRequest request) const
virtual

Creates an Amazon Lightsail bucket.

A bucket is a cloud storage resource available in the Lightsail object storage service. Use buckets to store objects such as data and its descriptive metadata. For more information about buckets, see Buckets in Amazon Lightsail in the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CreateBucketAccessKey()

virtual Model::CreateBucketAccessKeyOutcome Aws::Lightsail::LightsailClient::CreateBucketAccessKey ( const Model::CreateBucketAccessKeyRequest request) const
virtual

Creates a new access key for the specified Amazon Lightsail bucket. Access keys consist of an access key ID and corresponding secret access key.

Access keys grant full programmatic access to the specified bucket and its objects. You can have a maximum of two access keys per bucket. Use the GetBucketAccessKeys action to get a list of current access keys for a specific bucket. For more information about access keys, see Creating access keys for a bucket in Amazon Lightsail in the Amazon Lightsail Developer Guide.

The secretAccessKey value is returned only in response to the CreateBucketAccessKey action. You can get a secret access key only when you first create an access key; you cannot get the secret access key later. If you lose the secret access key, you must create a new access key.

See Also:

AWS API Reference

◆ CreateBucketAccessKeyAsync()

template<typename CreateBucketAccessKeyRequestT = Model::CreateBucketAccessKeyRequest>
void Aws::Lightsail::LightsailClient::CreateBucketAccessKeyAsync ( const CreateBucketAccessKeyRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateBucketAccessKey that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 409 of file LightsailClient.h.

◆ CreateBucketAccessKeyCallable()

template<typename CreateBucketAccessKeyRequestT = Model::CreateBucketAccessKeyRequest>
Model::CreateBucketAccessKeyOutcomeCallable Aws::Lightsail::LightsailClient::CreateBucketAccessKeyCallable ( const CreateBucketAccessKeyRequestT &  request) const
inline

A Callable wrapper for CreateBucketAccessKey that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 400 of file LightsailClient.h.

◆ CreateBucketAsync()

template<typename CreateBucketRequestT = Model::CreateBucketRequest>
void Aws::Lightsail::LightsailClient::CreateBucketAsync ( const CreateBucketRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateBucket that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 371 of file LightsailClient.h.

◆ CreateBucketCallable()

template<typename CreateBucketRequestT = Model::CreateBucketRequest>
Model::CreateBucketOutcomeCallable Aws::Lightsail::LightsailClient::CreateBucketCallable ( const CreateBucketRequestT &  request) const
inline

A Callable wrapper for CreateBucket that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 362 of file LightsailClient.h.

◆ CreateCertificate()

virtual Model::CreateCertificateOutcome Aws::Lightsail::LightsailClient::CreateCertificate ( const Model::CreateCertificateRequest request) const
virtual

Creates an SSL/TLS certificate for an Amazon Lightsail content delivery network (CDN) distribution and a container service.

After the certificate is valid, use the AttachCertificateToDistribution action to use the certificate and its domains with your distribution. Or use the UpdateContainerService action to use the certificate and its domains with your container service.

Only certificates created in the us-east-1 Amazon Web Services Region can be attached to Lightsail distributions. Lightsail distributions are global resources that can reference an origin in any Amazon Web Services Region, and distribute its content globally. However, all distributions are located in the us-east-1 Region.

See Also:

AWS API Reference

◆ CreateCertificateAsync()

template<typename CreateCertificateRequestT = Model::CreateCertificateRequest>
void Aws::Lightsail::LightsailClient::CreateCertificateAsync ( const CreateCertificateRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateCertificate that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 444 of file LightsailClient.h.

◆ CreateCertificateCallable()

template<typename CreateCertificateRequestT = Model::CreateCertificateRequest>
Model::CreateCertificateOutcomeCallable Aws::Lightsail::LightsailClient::CreateCertificateCallable ( const CreateCertificateRequestT &  request) const
inline

A Callable wrapper for CreateCertificate that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 435 of file LightsailClient.h.

◆ CreateCloudFormationStack()

virtual Model::CreateCloudFormationStackOutcome Aws::Lightsail::LightsailClient::CreateCloudFormationStack ( const Model::CreateCloudFormationStackRequest request) const
virtual

Creates an AWS CloudFormation stack, which creates a new Amazon EC2 instance from an exported Amazon Lightsail snapshot. This operation results in a CloudFormation stack record that can be used to track the AWS CloudFormation stack created. Use the get cloud formation stack records operation to get a list of the CloudFormation stacks created.

Wait until after your new Amazon EC2 instance is created before running the create cloud formation stack operation again with the same export snapshot record.

See Also:

AWS API Reference

◆ CreateCloudFormationStackAsync()

template<typename CreateCloudFormationStackRequestT = Model::CreateCloudFormationStackRequest>
void Aws::Lightsail::LightsailClient::CreateCloudFormationStackAsync ( const CreateCloudFormationStackRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateCloudFormationStack that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 476 of file LightsailClient.h.

◆ CreateCloudFormationStackCallable()

template<typename CreateCloudFormationStackRequestT = Model::CreateCloudFormationStackRequest>
Model::CreateCloudFormationStackOutcomeCallable Aws::Lightsail::LightsailClient::CreateCloudFormationStackCallable ( const CreateCloudFormationStackRequestT &  request) const
inline

A Callable wrapper for CreateCloudFormationStack that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 467 of file LightsailClient.h.

◆ CreateContactMethod()

virtual Model::CreateContactMethodOutcome Aws::Lightsail::LightsailClient::CreateContactMethod ( const Model::CreateContactMethodRequest request) const
virtual

Creates an email or SMS text message contact method.

A contact method is used to send you notifications about your Amazon Lightsail resources. You can add one email address and one mobile phone number contact method in each Amazon Web Services Region. However, SMS text messaging is not supported in some Amazon Web Services Regions, and SMS text messages cannot be sent to some countries/regions. For more information, see Notifications in Amazon Lightsail.

See Also:

AWS API Reference

◆ CreateContactMethodAsync()

template<typename CreateContactMethodRequestT = Model::CreateContactMethodRequest>
void Aws::Lightsail::LightsailClient::CreateContactMethodAsync ( const CreateContactMethodRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateContactMethod that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 508 of file LightsailClient.h.

◆ CreateContactMethodCallable()

template<typename CreateContactMethodRequestT = Model::CreateContactMethodRequest>
Model::CreateContactMethodOutcomeCallable Aws::Lightsail::LightsailClient::CreateContactMethodCallable ( const CreateContactMethodRequestT &  request) const
inline

A Callable wrapper for CreateContactMethod that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 499 of file LightsailClient.h.

◆ CreateContainerService()

virtual Model::CreateContainerServiceOutcome Aws::Lightsail::LightsailClient::CreateContainerService ( const Model::CreateContainerServiceRequest request) const
virtual

Creates an Amazon Lightsail container service.

A Lightsail container service is a compute resource to which you can deploy containers. For more information, see Container services in Amazon Lightsail in the Lightsail Dev Guide.

See Also:

AWS API Reference

◆ CreateContainerServiceAsync()

template<typename CreateContainerServiceRequestT = Model::CreateContainerServiceRequest>
void Aws::Lightsail::LightsailClient::CreateContainerServiceAsync ( const CreateContainerServiceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateContainerService that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 538 of file LightsailClient.h.

◆ CreateContainerServiceCallable()

template<typename CreateContainerServiceRequestT = Model::CreateContainerServiceRequest>
Model::CreateContainerServiceOutcomeCallable Aws::Lightsail::LightsailClient::CreateContainerServiceCallable ( const CreateContainerServiceRequestT &  request) const
inline

A Callable wrapper for CreateContainerService that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 529 of file LightsailClient.h.

◆ CreateContainerServiceDeployment()

virtual Model::CreateContainerServiceDeploymentOutcome Aws::Lightsail::LightsailClient::CreateContainerServiceDeployment ( const Model::CreateContainerServiceDeploymentRequest request) const
virtual

Creates a deployment for your Amazon Lightsail container service.

A deployment specifies the containers that will be launched on the container service and their settings, such as the ports to open, the environment variables to apply, and the launch command to run. It also specifies the container that will serve as the public endpoint of the deployment and its settings, such as the HTTP or HTTPS port to use, and the health check configuration.

You can deploy containers to your container service using container images from a public registry such as Amazon ECR Public, or from your local machine. For more information, see Creating container images for your Amazon Lightsail container services in the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CreateContainerServiceDeploymentAsync()

template<typename CreateContainerServiceDeploymentRequestT = Model::CreateContainerServiceDeploymentRequest>
void Aws::Lightsail::LightsailClient::CreateContainerServiceDeploymentAsync ( const CreateContainerServiceDeploymentRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateContainerServiceDeployment that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 574 of file LightsailClient.h.

◆ CreateContainerServiceDeploymentCallable()

template<typename CreateContainerServiceDeploymentRequestT = Model::CreateContainerServiceDeploymentRequest>
Model::CreateContainerServiceDeploymentOutcomeCallable Aws::Lightsail::LightsailClient::CreateContainerServiceDeploymentCallable ( const CreateContainerServiceDeploymentRequestT &  request) const
inline

A Callable wrapper for CreateContainerServiceDeployment that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 565 of file LightsailClient.h.

◆ CreateContainerServiceRegistryLogin()

virtual Model::CreateContainerServiceRegistryLoginOutcome Aws::Lightsail::LightsailClient::CreateContainerServiceRegistryLogin ( const Model::CreateContainerServiceRegistryLoginRequest request = {}) const
virtual

Creates a temporary set of log in credentials that you can use to log in to the Docker process on your local machine. After you're logged in, you can use the native Docker commands to push your local container images to the container image registry of your Amazon Lightsail account so that you can use them with your Lightsail container service. The log in credentials expire 12 hours after they are created, at which point you will need to create a new set of log in credentials.

You can only push container images to the container service registry of your Lightsail account. You cannot pull container images or perform any other container image management actions on the container service registry.

After you push your container images to the container image registry of your Lightsail account, use the RegisterContainerImage action to register the pushed images to a specific Lightsail container service.

This action is not required if you install and use the Lightsail Control (lightsailctl) plugin to push container images to your Lightsail container service. For more information, see Pushing and managing container images on your Amazon Lightsail container services in the Amazon Lightsail Developer Guide.

See Also:


AWS API Reference

◆ CreateContainerServiceRegistryLoginAsync()

template<typename CreateContainerServiceRegistryLoginRequestT = Model::CreateContainerServiceRegistryLoginRequest>
void Aws::Lightsail::LightsailClient::CreateContainerServiceRegistryLoginAsync ( const CreateContainerServiceRegistryLoginResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const CreateContainerServiceRegistryLoginRequestT &  request = {} 
) const
inline

An Async wrapper for CreateContainerServiceRegistryLogin that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 618 of file LightsailClient.h.

◆ CreateContainerServiceRegistryLoginCallable()

template<typename CreateContainerServiceRegistryLoginRequestT = Model::CreateContainerServiceRegistryLoginRequest>
Model::CreateContainerServiceRegistryLoginOutcomeCallable Aws::Lightsail::LightsailClient::CreateContainerServiceRegistryLoginCallable ( const CreateContainerServiceRegistryLoginRequestT &  request = {}) const
inline

A Callable wrapper for CreateContainerServiceRegistryLogin that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 609 of file LightsailClient.h.

◆ CreateDisk()

virtual Model::CreateDiskOutcome Aws::Lightsail::LightsailClient::CreateDisk ( const Model::CreateDiskRequest request) const
virtual

Creates a block storage disk that can be attached to an Amazon Lightsail instance in the same Availability Zone (us-east-2a).

The create disk operation supports tag-based access control via request tags. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CreateDiskAsync()

template<typename CreateDiskRequestT = Model::CreateDiskRequest>
void Aws::Lightsail::LightsailClient::CreateDiskAsync ( const CreateDiskRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateDisk that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 648 of file LightsailClient.h.

◆ CreateDiskCallable()

template<typename CreateDiskRequestT = Model::CreateDiskRequest>
Model::CreateDiskOutcomeCallable Aws::Lightsail::LightsailClient::CreateDiskCallable ( const CreateDiskRequestT &  request) const
inline

A Callable wrapper for CreateDisk that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 639 of file LightsailClient.h.

◆ CreateDiskFromSnapshot()

virtual Model::CreateDiskFromSnapshotOutcome Aws::Lightsail::LightsailClient::CreateDiskFromSnapshot ( const Model::CreateDiskFromSnapshotRequest request) const
virtual

Creates a block storage disk from a manual or automatic snapshot of a disk. The resulting disk can be attached to an Amazon Lightsail instance in the same Availability Zone (us-east-2a).

The create disk from snapshot operation supports tag-based access control via request tags and resource tags applied to the resource identified by disk snapshot name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CreateDiskFromSnapshotAsync()

template<typename CreateDiskFromSnapshotRequestT = Model::CreateDiskFromSnapshotRequest>
void Aws::Lightsail::LightsailClient::CreateDiskFromSnapshotAsync ( const CreateDiskFromSnapshotRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateDiskFromSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 680 of file LightsailClient.h.

◆ CreateDiskFromSnapshotCallable()

template<typename CreateDiskFromSnapshotRequestT = Model::CreateDiskFromSnapshotRequest>
Model::CreateDiskFromSnapshotOutcomeCallable Aws::Lightsail::LightsailClient::CreateDiskFromSnapshotCallable ( const CreateDiskFromSnapshotRequestT &  request) const
inline

A Callable wrapper for CreateDiskFromSnapshot that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 671 of file LightsailClient.h.

◆ CreateDiskSnapshot()

virtual Model::CreateDiskSnapshotOutcome Aws::Lightsail::LightsailClient::CreateDiskSnapshot ( const Model::CreateDiskSnapshotRequest request) const
virtual

Creates a snapshot of a block storage disk. You can use snapshots for backups, to make copies of disks, and to save data before shutting down a Lightsail instance.

You can take a snapshot of an attached disk that is in use; however, snapshots only capture data that has been written to your disk at the time the snapshot command is issued. This may exclude any data that has been cached by any applications or the operating system. If you can pause any file systems on the disk long enough to take a snapshot, your snapshot should be complete. Nevertheless, if you cannot pause all file writes to the disk, you should unmount the disk from within the Lightsail instance, issue the create disk snapshot command, and then remount the disk to ensure a consistent and complete snapshot. You may remount and use your disk while the snapshot status is pending.

You can also use this operation to create a snapshot of an instance's system volume. You might want to do this, for example, to recover data from the system volume of a botched instance or to create a backup of the system volume like you would for a block storage disk. To create a snapshot of a system volume, just define the instance name parameter when issuing the snapshot command, and a snapshot of the defined instance's system volume will be created. After the snapshot is available, you can create a block storage disk from the snapshot and attach it to a running instance to access the data on the disk.

The create disk snapshot operation supports tag-based access control via request tags. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CreateDiskSnapshotAsync()

template<typename CreateDiskSnapshotRequestT = Model::CreateDiskSnapshotRequest>
void Aws::Lightsail::LightsailClient::CreateDiskSnapshotAsync ( const CreateDiskSnapshotRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateDiskSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 727 of file LightsailClient.h.

◆ CreateDiskSnapshotCallable()

template<typename CreateDiskSnapshotRequestT = Model::CreateDiskSnapshotRequest>
Model::CreateDiskSnapshotOutcomeCallable Aws::Lightsail::LightsailClient::CreateDiskSnapshotCallable ( const CreateDiskSnapshotRequestT &  request) const
inline

A Callable wrapper for CreateDiskSnapshot that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 718 of file LightsailClient.h.

◆ CreateDistribution()

virtual Model::CreateDistributionOutcome Aws::Lightsail::LightsailClient::CreateDistribution ( const Model::CreateDistributionRequest request) const
virtual

Creates an Amazon Lightsail content delivery network (CDN) distribution.

A distribution is a globally distributed network of caching servers that improve the performance of your website or web application hosted on a Lightsail instance. For more information, see Content delivery networks in Amazon Lightsail.

See Also:

AWS API Reference

◆ CreateDistributionAsync()

template<typename CreateDistributionRequestT = Model::CreateDistributionRequest>
void Aws::Lightsail::LightsailClient::CreateDistributionAsync ( const CreateDistributionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateDistribution that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 757 of file LightsailClient.h.

◆ CreateDistributionCallable()

template<typename CreateDistributionRequestT = Model::CreateDistributionRequest>
Model::CreateDistributionOutcomeCallable Aws::Lightsail::LightsailClient::CreateDistributionCallable ( const CreateDistributionRequestT &  request) const
inline

A Callable wrapper for CreateDistribution that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 748 of file LightsailClient.h.

◆ CreateDomain()

virtual Model::CreateDomainOutcome Aws::Lightsail::LightsailClient::CreateDomain ( const Model::CreateDomainRequest request) const
virtual

Creates a domain resource for the specified domain (example.com).

The create domain operation supports tag-based access control via request tags. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CreateDomainAsync()

template<typename CreateDomainRequestT = Model::CreateDomainRequest>
void Aws::Lightsail::LightsailClient::CreateDomainAsync ( const CreateDomainRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateDomain that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 786 of file LightsailClient.h.

◆ CreateDomainCallable()

template<typename CreateDomainRequestT = Model::CreateDomainRequest>
Model::CreateDomainOutcomeCallable Aws::Lightsail::LightsailClient::CreateDomainCallable ( const CreateDomainRequestT &  request) const
inline

A Callable wrapper for CreateDomain that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 777 of file LightsailClient.h.

◆ CreateDomainEntry()

virtual Model::CreateDomainEntryOutcome Aws::Lightsail::LightsailClient::CreateDomainEntry ( const Model::CreateDomainEntryRequest request) const
virtual

Creates one of the following domain name system (DNS) records in a domain DNS zone: Address (A), canonical name (CNAME), mail exchanger (MX), name server (NS), start of authority (SOA), service locator (SRV), or text (TXT).

The create domain entry operation supports tag-based access control via resource tags applied to the resource identified by domain name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CreateDomainEntryAsync()

template<typename CreateDomainEntryRequestT = Model::CreateDomainEntryRequest>
void Aws::Lightsail::LightsailClient::CreateDomainEntryAsync ( const CreateDomainEntryRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateDomainEntry that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 818 of file LightsailClient.h.

◆ CreateDomainEntryCallable()

template<typename CreateDomainEntryRequestT = Model::CreateDomainEntryRequest>
Model::CreateDomainEntryOutcomeCallable Aws::Lightsail::LightsailClient::CreateDomainEntryCallable ( const CreateDomainEntryRequestT &  request) const
inline

A Callable wrapper for CreateDomainEntry that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 809 of file LightsailClient.h.

◆ CreateGUISessionAccessDetails()

virtual Model::CreateGUISessionAccessDetailsOutcome Aws::Lightsail::LightsailClient::CreateGUISessionAccessDetails ( const Model::CreateGUISessionAccessDetailsRequest request) const
virtual

Creates two URLs that are used to access a virtual computer’s graphical user interface (GUI) session. The primary URL initiates a web-based NICE DCV session to the virtual computer's application. The secondary URL initiates a web-based NICE DCV session to the virtual computer's operating session.

Use StartGUISession to open the session.

See Also:

AWS API Reference

◆ CreateGUISessionAccessDetailsAsync()

template<typename CreateGUISessionAccessDetailsRequestT = Model::CreateGUISessionAccessDetailsRequest>
void Aws::Lightsail::LightsailClient::CreateGUISessionAccessDetailsAsync ( const CreateGUISessionAccessDetailsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateGUISessionAccessDetails that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 847 of file LightsailClient.h.

◆ CreateGUISessionAccessDetailsCallable()

template<typename CreateGUISessionAccessDetailsRequestT = Model::CreateGUISessionAccessDetailsRequest>
Model::CreateGUISessionAccessDetailsOutcomeCallable Aws::Lightsail::LightsailClient::CreateGUISessionAccessDetailsCallable ( const CreateGUISessionAccessDetailsRequestT &  request) const
inline

A Callable wrapper for CreateGUISessionAccessDetails that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 838 of file LightsailClient.h.

◆ CreateInstances()

virtual Model::CreateInstancesOutcome Aws::Lightsail::LightsailClient::CreateInstances ( const Model::CreateInstancesRequest request) const
virtual

Creates one or more Amazon Lightsail instances.

The create instances operation supports tag-based access control via request tags. For more information, see the Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CreateInstancesAsync()

template<typename CreateInstancesRequestT = Model::CreateInstancesRequest>
void Aws::Lightsail::LightsailClient::CreateInstancesAsync ( const CreateInstancesRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateInstances that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 906 of file LightsailClient.h.

◆ CreateInstancesCallable()

template<typename CreateInstancesRequestT = Model::CreateInstancesRequest>
Model::CreateInstancesOutcomeCallable Aws::Lightsail::LightsailClient::CreateInstancesCallable ( const CreateInstancesRequestT &  request) const
inline

A Callable wrapper for CreateInstances that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 897 of file LightsailClient.h.

◆ CreateInstancesFromSnapshot()

virtual Model::CreateInstancesFromSnapshotOutcome Aws::Lightsail::LightsailClient::CreateInstancesFromSnapshot ( const Model::CreateInstancesFromSnapshotRequest request) const
virtual

Creates one or more new instances from a manual or automatic snapshot of an instance.

The create instances from snapshot operation supports tag-based access control via request tags and resource tags applied to the resource identified by instance snapshot name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CreateInstancesFromSnapshotAsync()

template<typename CreateInstancesFromSnapshotRequestT = Model::CreateInstancesFromSnapshotRequest>
void Aws::Lightsail::LightsailClient::CreateInstancesFromSnapshotAsync ( const CreateInstancesFromSnapshotRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateInstancesFromSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 937 of file LightsailClient.h.

◆ CreateInstancesFromSnapshotCallable()

template<typename CreateInstancesFromSnapshotRequestT = Model::CreateInstancesFromSnapshotRequest>
Model::CreateInstancesFromSnapshotOutcomeCallable Aws::Lightsail::LightsailClient::CreateInstancesFromSnapshotCallable ( const CreateInstancesFromSnapshotRequestT &  request) const
inline

A Callable wrapper for CreateInstancesFromSnapshot that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 928 of file LightsailClient.h.

◆ CreateInstanceSnapshot()

virtual Model::CreateInstanceSnapshotOutcome Aws::Lightsail::LightsailClient::CreateInstanceSnapshot ( const Model::CreateInstanceSnapshotRequest request) const
virtual

Creates a snapshot of a specific virtual private server, or instance. You can use a snapshot to create a new instance that is based on that snapshot.

The create instance snapshot operation supports tag-based access control via request tags. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CreateInstanceSnapshotAsync()

template<typename CreateInstanceSnapshotRequestT = Model::CreateInstanceSnapshotRequest>
void Aws::Lightsail::LightsailClient::CreateInstanceSnapshotAsync ( const CreateInstanceSnapshotRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateInstanceSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 877 of file LightsailClient.h.

◆ CreateInstanceSnapshotCallable()

template<typename CreateInstanceSnapshotRequestT = Model::CreateInstanceSnapshotRequest>
Model::CreateInstanceSnapshotOutcomeCallable Aws::Lightsail::LightsailClient::CreateInstanceSnapshotCallable ( const CreateInstanceSnapshotRequestT &  request) const
inline

A Callable wrapper for CreateInstanceSnapshot that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 868 of file LightsailClient.h.

◆ CreateKeyPair()

virtual Model::CreateKeyPairOutcome Aws::Lightsail::LightsailClient::CreateKeyPair ( const Model::CreateKeyPairRequest request) const
virtual

Creates a custom SSH key pair that you can use with an Amazon Lightsail instance.

Use the DownloadDefaultKeyPair action to create a Lightsail default key pair in an Amazon Web Services Region where a default key pair does not currently exist.

The create key pair operation supports tag-based access control via request tags. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CreateKeyPairAsync()

template<typename CreateKeyPairRequestT = Model::CreateKeyPairRequest>
void Aws::Lightsail::LightsailClient::CreateKeyPairAsync ( const CreateKeyPairRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateKeyPair that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 970 of file LightsailClient.h.

◆ CreateKeyPairCallable()

template<typename CreateKeyPairRequestT = Model::CreateKeyPairRequest>
Model::CreateKeyPairOutcomeCallable Aws::Lightsail::LightsailClient::CreateKeyPairCallable ( const CreateKeyPairRequestT &  request) const
inline

A Callable wrapper for CreateKeyPair that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 961 of file LightsailClient.h.

◆ CreateLoadBalancer()

virtual Model::CreateLoadBalancerOutcome Aws::Lightsail::LightsailClient::CreateLoadBalancer ( const Model::CreateLoadBalancerRequest request) const
virtual

Creates a Lightsail load balancer. To learn more about deciding whether to load balance your application, see Configure your Lightsail instances for load balancing. You can create up to 5 load balancers per AWS Region in your account.

When you create a load balancer, you can specify a unique name and port settings. To change additional load balancer settings, use the UpdateLoadBalancerAttribute operation.

The create load balancer operation supports tag-based access control via request tags. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CreateLoadBalancerAsync()

template<typename CreateLoadBalancerRequestT = Model::CreateLoadBalancerRequest>
void Aws::Lightsail::LightsailClient::CreateLoadBalancerAsync ( const CreateLoadBalancerRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateLoadBalancer that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1005 of file LightsailClient.h.

◆ CreateLoadBalancerCallable()

template<typename CreateLoadBalancerRequestT = Model::CreateLoadBalancerRequest>
Model::CreateLoadBalancerOutcomeCallable Aws::Lightsail::LightsailClient::CreateLoadBalancerCallable ( const CreateLoadBalancerRequestT &  request) const
inline

A Callable wrapper for CreateLoadBalancer that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 996 of file LightsailClient.h.

◆ CreateLoadBalancerTlsCertificate()

virtual Model::CreateLoadBalancerTlsCertificateOutcome Aws::Lightsail::LightsailClient::CreateLoadBalancerTlsCertificate ( const Model::CreateLoadBalancerTlsCertificateRequest request) const
virtual

Creates an SSL/TLS certificate for an Amazon Lightsail load balancer.

TLS is just an updated, more secure version of Secure Socket Layer (SSL).

The CreateLoadBalancerTlsCertificate operation supports tag-based access control via resource tags applied to the resource identified by load balancer name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CreateLoadBalancerTlsCertificateAsync()

template<typename CreateLoadBalancerTlsCertificateRequestT = Model::CreateLoadBalancerTlsCertificateRequest>
void Aws::Lightsail::LightsailClient::CreateLoadBalancerTlsCertificateAsync ( const CreateLoadBalancerTlsCertificateRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateLoadBalancerTlsCertificate that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1036 of file LightsailClient.h.

◆ CreateLoadBalancerTlsCertificateCallable()

template<typename CreateLoadBalancerTlsCertificateRequestT = Model::CreateLoadBalancerTlsCertificateRequest>
Model::CreateLoadBalancerTlsCertificateOutcomeCallable Aws::Lightsail::LightsailClient::CreateLoadBalancerTlsCertificateCallable ( const CreateLoadBalancerTlsCertificateRequestT &  request) const
inline

A Callable wrapper for CreateLoadBalancerTlsCertificate that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1027 of file LightsailClient.h.

◆ CreateRelationalDatabase()

virtual Model::CreateRelationalDatabaseOutcome Aws::Lightsail::LightsailClient::CreateRelationalDatabase ( const Model::CreateRelationalDatabaseRequest request) const
virtual

Creates a new database in Amazon Lightsail.

The create relational database operation supports tag-based access control via request tags. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CreateRelationalDatabaseAsync()

template<typename CreateRelationalDatabaseRequestT = Model::CreateRelationalDatabaseRequest>
void Aws::Lightsail::LightsailClient::CreateRelationalDatabaseAsync ( const CreateRelationalDatabaseRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateRelationalDatabase that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1065 of file LightsailClient.h.

◆ CreateRelationalDatabaseCallable()

template<typename CreateRelationalDatabaseRequestT = Model::CreateRelationalDatabaseRequest>
Model::CreateRelationalDatabaseOutcomeCallable Aws::Lightsail::LightsailClient::CreateRelationalDatabaseCallable ( const CreateRelationalDatabaseRequestT &  request) const
inline

A Callable wrapper for CreateRelationalDatabase that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1056 of file LightsailClient.h.

◆ CreateRelationalDatabaseFromSnapshot()

virtual Model::CreateRelationalDatabaseFromSnapshotOutcome Aws::Lightsail::LightsailClient::CreateRelationalDatabaseFromSnapshot ( const Model::CreateRelationalDatabaseFromSnapshotRequest request) const
virtual

Creates a new database from an existing database snapshot in Amazon Lightsail.

You can create a new database from a snapshot in if something goes wrong with your original database, or to change it to a different plan, such as a high availability or standard plan.

The create relational database from snapshot operation supports tag-based access control via request tags and resource tags applied to the resource identified by relationalDatabaseSnapshotName. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CreateRelationalDatabaseFromSnapshotAsync()

template<typename CreateRelationalDatabaseFromSnapshotRequestT = Model::CreateRelationalDatabaseFromSnapshotRequest>
void Aws::Lightsail::LightsailClient::CreateRelationalDatabaseFromSnapshotAsync ( const CreateRelationalDatabaseFromSnapshotRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateRelationalDatabaseFromSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1098 of file LightsailClient.h.

◆ CreateRelationalDatabaseFromSnapshotCallable()

template<typename CreateRelationalDatabaseFromSnapshotRequestT = Model::CreateRelationalDatabaseFromSnapshotRequest>
Model::CreateRelationalDatabaseFromSnapshotOutcomeCallable Aws::Lightsail::LightsailClient::CreateRelationalDatabaseFromSnapshotCallable ( const CreateRelationalDatabaseFromSnapshotRequestT &  request) const
inline

A Callable wrapper for CreateRelationalDatabaseFromSnapshot that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1089 of file LightsailClient.h.

◆ CreateRelationalDatabaseSnapshot()

virtual Model::CreateRelationalDatabaseSnapshotOutcome Aws::Lightsail::LightsailClient::CreateRelationalDatabaseSnapshot ( const Model::CreateRelationalDatabaseSnapshotRequest request) const
virtual

Creates a snapshot of your database in Amazon Lightsail. You can use snapshots for backups, to make copies of a database, and to save data before deleting a database.

The create relational database snapshot operation supports tag-based access control via request tags. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ CreateRelationalDatabaseSnapshotAsync()

template<typename CreateRelationalDatabaseSnapshotRequestT = Model::CreateRelationalDatabaseSnapshotRequest>
void Aws::Lightsail::LightsailClient::CreateRelationalDatabaseSnapshotAsync ( const CreateRelationalDatabaseSnapshotRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateRelationalDatabaseSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1129 of file LightsailClient.h.

◆ CreateRelationalDatabaseSnapshotCallable()

template<typename CreateRelationalDatabaseSnapshotRequestT = Model::CreateRelationalDatabaseSnapshotRequest>
Model::CreateRelationalDatabaseSnapshotOutcomeCallable Aws::Lightsail::LightsailClient::CreateRelationalDatabaseSnapshotCallable ( const CreateRelationalDatabaseSnapshotRequestT &  request) const
inline

A Callable wrapper for CreateRelationalDatabaseSnapshot that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1120 of file LightsailClient.h.

◆ DeleteAlarm()

virtual Model::DeleteAlarmOutcome Aws::Lightsail::LightsailClient::DeleteAlarm ( const Model::DeleteAlarmRequest request) const
virtual

Deletes an alarm.

An alarm is used to monitor a single metric for one of your resources. When a metric condition is met, the alarm can notify you by email, SMS text message, and a banner displayed on the Amazon Lightsail console. For more information, see Alarms in Amazon Lightsail.

See Also:

AWS API Reference

◆ DeleteAlarmAsync()

template<typename DeleteAlarmRequestT = Model::DeleteAlarmRequest>
void Aws::Lightsail::LightsailClient::DeleteAlarmAsync ( const DeleteAlarmRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteAlarm that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1159 of file LightsailClient.h.

◆ DeleteAlarmCallable()

template<typename DeleteAlarmRequestT = Model::DeleteAlarmRequest>
Model::DeleteAlarmOutcomeCallable Aws::Lightsail::LightsailClient::DeleteAlarmCallable ( const DeleteAlarmRequestT &  request) const
inline

A Callable wrapper for DeleteAlarm that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1150 of file LightsailClient.h.

◆ DeleteAutoSnapshot()

virtual Model::DeleteAutoSnapshotOutcome Aws::Lightsail::LightsailClient::DeleteAutoSnapshot ( const Model::DeleteAutoSnapshotRequest request) const
virtual

Deletes an automatic snapshot of an instance or disk. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ DeleteAutoSnapshotAsync()

template<typename DeleteAutoSnapshotRequestT = Model::DeleteAutoSnapshotRequest>
void Aws::Lightsail::LightsailClient::DeleteAutoSnapshotAsync ( const DeleteAutoSnapshotRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteAutoSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1187 of file LightsailClient.h.

◆ DeleteAutoSnapshotCallable()

template<typename DeleteAutoSnapshotRequestT = Model::DeleteAutoSnapshotRequest>
Model::DeleteAutoSnapshotOutcomeCallable Aws::Lightsail::LightsailClient::DeleteAutoSnapshotCallable ( const DeleteAutoSnapshotRequestT &  request) const
inline

A Callable wrapper for DeleteAutoSnapshot that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1178 of file LightsailClient.h.

◆ DeleteBucket()

virtual Model::DeleteBucketOutcome Aws::Lightsail::LightsailClient::DeleteBucket ( const Model::DeleteBucketRequest request) const
virtual

Deletes a Amazon Lightsail bucket.

When you delete your bucket, the bucket name is released and can be reused for a new bucket in your account or another Amazon Web Services account.

See Also:

AWS API Reference

◆ DeleteBucketAccessKey()

virtual Model::DeleteBucketAccessKeyOutcome Aws::Lightsail::LightsailClient::DeleteBucketAccessKey ( const Model::DeleteBucketAccessKeyRequest request) const
virtual

Deletes an access key for the specified Amazon Lightsail bucket.

We recommend that you delete an access key if the secret access key is compromised.

For more information about access keys, see Creating access keys for a bucket in Amazon Lightsail in the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ DeleteBucketAccessKeyAsync()

template<typename DeleteBucketAccessKeyRequestT = Model::DeleteBucketAccessKeyRequest>
void Aws::Lightsail::LightsailClient::DeleteBucketAccessKeyAsync ( const DeleteBucketAccessKeyRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteBucketAccessKey that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1244 of file LightsailClient.h.

◆ DeleteBucketAccessKeyCallable()

template<typename DeleteBucketAccessKeyRequestT = Model::DeleteBucketAccessKeyRequest>
Model::DeleteBucketAccessKeyOutcomeCallable Aws::Lightsail::LightsailClient::DeleteBucketAccessKeyCallable ( const DeleteBucketAccessKeyRequestT &  request) const
inline

A Callable wrapper for DeleteBucketAccessKey that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1235 of file LightsailClient.h.

◆ DeleteBucketAsync()

template<typename DeleteBucketRequestT = Model::DeleteBucketRequest>
void Aws::Lightsail::LightsailClient::DeleteBucketAsync ( const DeleteBucketRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteBucket that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1214 of file LightsailClient.h.

◆ DeleteBucketCallable()

template<typename DeleteBucketRequestT = Model::DeleteBucketRequest>
Model::DeleteBucketOutcomeCallable Aws::Lightsail::LightsailClient::DeleteBucketCallable ( const DeleteBucketRequestT &  request) const
inline

A Callable wrapper for DeleteBucket that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1205 of file LightsailClient.h.

◆ DeleteCertificate()

virtual Model::DeleteCertificateOutcome Aws::Lightsail::LightsailClient::DeleteCertificate ( const Model::DeleteCertificateRequest request) const
virtual

Deletes an SSL/TLS certificate for your Amazon Lightsail content delivery network (CDN) distribution.

Certificates that are currently attached to a distribution cannot be deleted. Use the DetachCertificateFromDistribution action to detach a certificate from a distribution.

See Also:

AWS API Reference

◆ DeleteCertificateAsync()

template<typename DeleteCertificateRequestT = Model::DeleteCertificateRequest>
void Aws::Lightsail::LightsailClient::DeleteCertificateAsync ( const DeleteCertificateRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteCertificate that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1273 of file LightsailClient.h.

◆ DeleteCertificateCallable()

template<typename DeleteCertificateRequestT = Model::DeleteCertificateRequest>
Model::DeleteCertificateOutcomeCallable Aws::Lightsail::LightsailClient::DeleteCertificateCallable ( const DeleteCertificateRequestT &  request) const
inline

A Callable wrapper for DeleteCertificate that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1264 of file LightsailClient.h.

◆ DeleteContactMethod()

virtual Model::DeleteContactMethodOutcome Aws::Lightsail::LightsailClient::DeleteContactMethod ( const Model::DeleteContactMethodRequest request) const
virtual

Deletes a contact method.

A contact method is used to send you notifications about your Amazon Lightsail resources. You can add one email address and one mobile phone number contact method in each Amazon Web Services Region. However, SMS text messaging is not supported in some Amazon Web Services Regions, and SMS text messages cannot be sent to some countries/regions. For more information, see Notifications in Amazon Lightsail.

See Also:

AWS API Reference

◆ DeleteContactMethodAsync()

template<typename DeleteContactMethodRequestT = Model::DeleteContactMethodRequest>
void Aws::Lightsail::LightsailClient::DeleteContactMethodAsync ( const DeleteContactMethodRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteContactMethod that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1305 of file LightsailClient.h.

◆ DeleteContactMethodCallable()

template<typename DeleteContactMethodRequestT = Model::DeleteContactMethodRequest>
Model::DeleteContactMethodOutcomeCallable Aws::Lightsail::LightsailClient::DeleteContactMethodCallable ( const DeleteContactMethodRequestT &  request) const
inline

A Callable wrapper for DeleteContactMethod that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1296 of file LightsailClient.h.

◆ DeleteContainerImage()

virtual Model::DeleteContainerImageOutcome Aws::Lightsail::LightsailClient::DeleteContainerImage ( const Model::DeleteContainerImageRequest request) const
virtual

Deletes a container image that is registered to your Amazon Lightsail container service.

See Also:

AWS API Reference

◆ DeleteContainerImageAsync()

template<typename DeleteContainerImageRequestT = Model::DeleteContainerImageRequest>
void Aws::Lightsail::LightsailClient::DeleteContainerImageAsync ( const DeleteContainerImageRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteContainerImage that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1331 of file LightsailClient.h.

◆ DeleteContainerImageCallable()

template<typename DeleteContainerImageRequestT = Model::DeleteContainerImageRequest>
Model::DeleteContainerImageOutcomeCallable Aws::Lightsail::LightsailClient::DeleteContainerImageCallable ( const DeleteContainerImageRequestT &  request) const
inline

A Callable wrapper for DeleteContainerImage that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1322 of file LightsailClient.h.

◆ DeleteContainerService()

virtual Model::DeleteContainerServiceOutcome Aws::Lightsail::LightsailClient::DeleteContainerService ( const Model::DeleteContainerServiceRequest request) const
virtual

Deletes your Amazon Lightsail container service.

See Also:


AWS API Reference

◆ DeleteContainerServiceAsync()

template<typename DeleteContainerServiceRequestT = Model::DeleteContainerServiceRequest>
void Aws::Lightsail::LightsailClient::DeleteContainerServiceAsync ( const DeleteContainerServiceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteContainerService that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1357 of file LightsailClient.h.

◆ DeleteContainerServiceCallable()

template<typename DeleteContainerServiceRequestT = Model::DeleteContainerServiceRequest>
Model::DeleteContainerServiceOutcomeCallable Aws::Lightsail::LightsailClient::DeleteContainerServiceCallable ( const DeleteContainerServiceRequestT &  request) const
inline

A Callable wrapper for DeleteContainerService that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1348 of file LightsailClient.h.

◆ DeleteDisk()

virtual Model::DeleteDiskOutcome Aws::Lightsail::LightsailClient::DeleteDisk ( const Model::DeleteDiskRequest request) const
virtual

Deletes the specified block storage disk. The disk must be in the available state (not attached to a Lightsail instance).

The disk may remain in the deleting state for several minutes.

The delete disk operation supports tag-based access control via resource tags applied to the resource identified by disk name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ DeleteDiskAsync()

template<typename DeleteDiskRequestT = Model::DeleteDiskRequest>
void Aws::Lightsail::LightsailClient::DeleteDiskAsync ( const DeleteDiskRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteDisk that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1389 of file LightsailClient.h.

◆ DeleteDiskCallable()

template<typename DeleteDiskRequestT = Model::DeleteDiskRequest>
Model::DeleteDiskOutcomeCallable Aws::Lightsail::LightsailClient::DeleteDiskCallable ( const DeleteDiskRequestT &  request) const
inline

A Callable wrapper for DeleteDisk that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1380 of file LightsailClient.h.

◆ DeleteDiskSnapshot()

virtual Model::DeleteDiskSnapshotOutcome Aws::Lightsail::LightsailClient::DeleteDiskSnapshot ( const Model::DeleteDiskSnapshotRequest request) const
virtual

Deletes the specified disk snapshot.

When you make periodic snapshots of a disk, the snapshots are incremental, and only the blocks on the device that have changed since your last snapshot are saved in the new snapshot. When you delete a snapshot, only the data not needed for any other snapshot is removed. So regardless of which prior snapshots have been deleted, all active snapshots will have access to all the information needed to restore the disk.

The delete disk snapshot operation supports tag-based access control via resource tags applied to the resource identified by disk snapshot name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ DeleteDiskSnapshotAsync()

template<typename DeleteDiskSnapshotRequestT = Model::DeleteDiskSnapshotRequest>
void Aws::Lightsail::LightsailClient::DeleteDiskSnapshotAsync ( const DeleteDiskSnapshotRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteDiskSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1424 of file LightsailClient.h.

◆ DeleteDiskSnapshotCallable()

template<typename DeleteDiskSnapshotRequestT = Model::DeleteDiskSnapshotRequest>
Model::DeleteDiskSnapshotOutcomeCallable Aws::Lightsail::LightsailClient::DeleteDiskSnapshotCallable ( const DeleteDiskSnapshotRequestT &  request) const
inline

A Callable wrapper for DeleteDiskSnapshot that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1415 of file LightsailClient.h.

◆ DeleteDistribution()

virtual Model::DeleteDistributionOutcome Aws::Lightsail::LightsailClient::DeleteDistribution ( const Model::DeleteDistributionRequest request = {}) const
virtual

Deletes your Amazon Lightsail content delivery network (CDN) distribution.

See Also:

AWS API Reference

◆ DeleteDistributionAsync()

template<typename DeleteDistributionRequestT = Model::DeleteDistributionRequest>
void Aws::Lightsail::LightsailClient::DeleteDistributionAsync ( const DeleteDistributionResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const DeleteDistributionRequestT &  request = {} 
) const
inline

An Async wrapper for DeleteDistribution that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1450 of file LightsailClient.h.

◆ DeleteDistributionCallable()

template<typename DeleteDistributionRequestT = Model::DeleteDistributionRequest>
Model::DeleteDistributionOutcomeCallable Aws::Lightsail::LightsailClient::DeleteDistributionCallable ( const DeleteDistributionRequestT &  request = {}) const
inline

A Callable wrapper for DeleteDistribution that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1441 of file LightsailClient.h.

◆ DeleteDomain()

virtual Model::DeleteDomainOutcome Aws::Lightsail::LightsailClient::DeleteDomain ( const Model::DeleteDomainRequest request) const
virtual

Deletes the specified domain recordset and all of its domain records.

The delete domain operation supports tag-based access control via resource tags applied to the resource identified by domain name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ DeleteDomainAsync()

template<typename DeleteDomainRequestT = Model::DeleteDomainRequest>
void Aws::Lightsail::LightsailClient::DeleteDomainAsync ( const DeleteDomainRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteDomain that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1480 of file LightsailClient.h.

◆ DeleteDomainCallable()

template<typename DeleteDomainRequestT = Model::DeleteDomainRequest>
Model::DeleteDomainOutcomeCallable Aws::Lightsail::LightsailClient::DeleteDomainCallable ( const DeleteDomainRequestT &  request) const
inline

A Callable wrapper for DeleteDomain that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1471 of file LightsailClient.h.

◆ DeleteDomainEntry()

virtual Model::DeleteDomainEntryOutcome Aws::Lightsail::LightsailClient::DeleteDomainEntry ( const Model::DeleteDomainEntryRequest request) const
virtual

Deletes a specific domain entry.

The delete domain entry operation supports tag-based access control via resource tags applied to the resource identified by domain name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ DeleteDomainEntryAsync()

template<typename DeleteDomainEntryRequestT = Model::DeleteDomainEntryRequest>
void Aws::Lightsail::LightsailClient::DeleteDomainEntryAsync ( const DeleteDomainEntryRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteDomainEntry that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1510 of file LightsailClient.h.

◆ DeleteDomainEntryCallable()

template<typename DeleteDomainEntryRequestT = Model::DeleteDomainEntryRequest>
Model::DeleteDomainEntryOutcomeCallable Aws::Lightsail::LightsailClient::DeleteDomainEntryCallable ( const DeleteDomainEntryRequestT &  request) const
inline

A Callable wrapper for DeleteDomainEntry that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1501 of file LightsailClient.h.

◆ DeleteInstance()

virtual Model::DeleteInstanceOutcome Aws::Lightsail::LightsailClient::DeleteInstance ( const Model::DeleteInstanceRequest request) const
virtual

Deletes an Amazon Lightsail instance.

The delete instance operation supports tag-based access control via resource tags applied to the resource identified by instance name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ DeleteInstanceAsync()

template<typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
void Aws::Lightsail::LightsailClient::DeleteInstanceAsync ( const DeleteInstanceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteInstance that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1540 of file LightsailClient.h.

◆ DeleteInstanceCallable()

template<typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
Model::DeleteInstanceOutcomeCallable Aws::Lightsail::LightsailClient::DeleteInstanceCallable ( const DeleteInstanceRequestT &  request) const
inline

A Callable wrapper for DeleteInstance that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1531 of file LightsailClient.h.

◆ DeleteInstanceSnapshot()

virtual Model::DeleteInstanceSnapshotOutcome Aws::Lightsail::LightsailClient::DeleteInstanceSnapshot ( const Model::DeleteInstanceSnapshotRequest request) const
virtual

Deletes a specific snapshot of a virtual private server (or instance).

The delete instance snapshot operation supports tag-based access control via resource tags applied to the resource identified by instance snapshot name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ DeleteInstanceSnapshotAsync()

template<typename DeleteInstanceSnapshotRequestT = Model::DeleteInstanceSnapshotRequest>
void Aws::Lightsail::LightsailClient::DeleteInstanceSnapshotAsync ( const DeleteInstanceSnapshotRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteInstanceSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1571 of file LightsailClient.h.

◆ DeleteInstanceSnapshotCallable()

template<typename DeleteInstanceSnapshotRequestT = Model::DeleteInstanceSnapshotRequest>
Model::DeleteInstanceSnapshotOutcomeCallable Aws::Lightsail::LightsailClient::DeleteInstanceSnapshotCallable ( const DeleteInstanceSnapshotRequestT &  request) const
inline

A Callable wrapper for DeleteInstanceSnapshot that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1562 of file LightsailClient.h.

◆ DeleteKeyPair()

virtual Model::DeleteKeyPairOutcome Aws::Lightsail::LightsailClient::DeleteKeyPair ( const Model::DeleteKeyPairRequest request) const
virtual

Deletes the specified key pair by removing the public key from Amazon Lightsail.

You can delete key pairs that were created using the ImportKeyPair and CreateKeyPair actions, as well as the Lightsail default key pair. A new default key pair will not be created unless you launch an instance without specifying a custom key pair, or you call the DownloadDefaultKeyPair API.

The delete key pair operation supports tag-based access control via resource tags applied to the resource identified by key pair name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ DeleteKeyPairAsync()

template<typename DeleteKeyPairRequestT = Model::DeleteKeyPairRequest>
void Aws::Lightsail::LightsailClient::DeleteKeyPairAsync ( const DeleteKeyPairRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteKeyPair that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1609 of file LightsailClient.h.

◆ DeleteKeyPairCallable()

template<typename DeleteKeyPairRequestT = Model::DeleteKeyPairRequest>
Model::DeleteKeyPairOutcomeCallable Aws::Lightsail::LightsailClient::DeleteKeyPairCallable ( const DeleteKeyPairRequestT &  request) const
inline

A Callable wrapper for DeleteKeyPair that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1600 of file LightsailClient.h.

◆ DeleteKnownHostKeys()

virtual Model::DeleteKnownHostKeysOutcome Aws::Lightsail::LightsailClient::DeleteKnownHostKeys ( const Model::DeleteKnownHostKeysRequest request) const
virtual

Deletes the known host key or certificate used by the Amazon Lightsail browser-based SSH or RDP clients to authenticate an instance. This operation enables the Lightsail browser-based SSH or RDP clients to connect to the instance after a host key mismatch.

Perform this operation only if you were expecting the host key or certificate mismatch or if you are familiar with the new host key or certificate on the instance. For more information, see Troubleshooting connection issues when using the Amazon Lightsail browser-based SSH or RDP client.

See Also:

AWS API Reference

◆ DeleteKnownHostKeysAsync()

template<typename DeleteKnownHostKeysRequestT = Model::DeleteKnownHostKeysRequest>
void Aws::Lightsail::LightsailClient::DeleteKnownHostKeysAsync ( const DeleteKnownHostKeysRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteKnownHostKeys that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1643 of file LightsailClient.h.

◆ DeleteKnownHostKeysCallable()

template<typename DeleteKnownHostKeysRequestT = Model::DeleteKnownHostKeysRequest>
Model::DeleteKnownHostKeysOutcomeCallable Aws::Lightsail::LightsailClient::DeleteKnownHostKeysCallable ( const DeleteKnownHostKeysRequestT &  request) const
inline

A Callable wrapper for DeleteKnownHostKeys that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1634 of file LightsailClient.h.

◆ DeleteLoadBalancer()

virtual Model::DeleteLoadBalancerOutcome Aws::Lightsail::LightsailClient::DeleteLoadBalancer ( const Model::DeleteLoadBalancerRequest request) const
virtual

Deletes a Lightsail load balancer and all its associated SSL/TLS certificates. Once the load balancer is deleted, you will need to create a new load balancer, create a new certificate, and verify domain ownership again.

The delete load balancer operation supports tag-based access control via resource tags applied to the resource identified by load balancer name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ DeleteLoadBalancerAsync()

template<typename DeleteLoadBalancerRequestT = Model::DeleteLoadBalancerRequest>
void Aws::Lightsail::LightsailClient::DeleteLoadBalancerAsync ( const DeleteLoadBalancerRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteLoadBalancer that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1675 of file LightsailClient.h.

◆ DeleteLoadBalancerCallable()

template<typename DeleteLoadBalancerRequestT = Model::DeleteLoadBalancerRequest>
Model::DeleteLoadBalancerOutcomeCallable Aws::Lightsail::LightsailClient::DeleteLoadBalancerCallable ( const DeleteLoadBalancerRequestT &  request) const
inline

A Callable wrapper for DeleteLoadBalancer that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1666 of file LightsailClient.h.

◆ DeleteLoadBalancerTlsCertificate()

virtual Model::DeleteLoadBalancerTlsCertificateOutcome Aws::Lightsail::LightsailClient::DeleteLoadBalancerTlsCertificate ( const Model::DeleteLoadBalancerTlsCertificateRequest request) const
virtual

Deletes an SSL/TLS certificate associated with a Lightsail load balancer.

The DeleteLoadBalancerTlsCertificate operation supports tag-based access control via resource tags applied to the resource identified by load balancer name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ DeleteLoadBalancerTlsCertificateAsync()

template<typename DeleteLoadBalancerTlsCertificateRequestT = Model::DeleteLoadBalancerTlsCertificateRequest>
void Aws::Lightsail::LightsailClient::DeleteLoadBalancerTlsCertificateAsync ( const DeleteLoadBalancerTlsCertificateRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteLoadBalancerTlsCertificate that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1705 of file LightsailClient.h.

◆ DeleteLoadBalancerTlsCertificateCallable()

template<typename DeleteLoadBalancerTlsCertificateRequestT = Model::DeleteLoadBalancerTlsCertificateRequest>
Model::DeleteLoadBalancerTlsCertificateOutcomeCallable Aws::Lightsail::LightsailClient::DeleteLoadBalancerTlsCertificateCallable ( const DeleteLoadBalancerTlsCertificateRequestT &  request) const
inline

A Callable wrapper for DeleteLoadBalancerTlsCertificate that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1696 of file LightsailClient.h.

◆ DeleteRelationalDatabase()

virtual Model::DeleteRelationalDatabaseOutcome Aws::Lightsail::LightsailClient::DeleteRelationalDatabase ( const Model::DeleteRelationalDatabaseRequest request) const
virtual

Deletes a database in Amazon Lightsail.

The delete relational database operation supports tag-based access control via resource tags applied to the resource identified by relationalDatabaseName. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ DeleteRelationalDatabaseAsync()

template<typename DeleteRelationalDatabaseRequestT = Model::DeleteRelationalDatabaseRequest>
void Aws::Lightsail::LightsailClient::DeleteRelationalDatabaseAsync ( const DeleteRelationalDatabaseRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteRelationalDatabase that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1735 of file LightsailClient.h.

◆ DeleteRelationalDatabaseCallable()

template<typename DeleteRelationalDatabaseRequestT = Model::DeleteRelationalDatabaseRequest>
Model::DeleteRelationalDatabaseOutcomeCallable Aws::Lightsail::LightsailClient::DeleteRelationalDatabaseCallable ( const DeleteRelationalDatabaseRequestT &  request) const
inline

A Callable wrapper for DeleteRelationalDatabase that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1726 of file LightsailClient.h.

◆ DeleteRelationalDatabaseSnapshot()

virtual Model::DeleteRelationalDatabaseSnapshotOutcome Aws::Lightsail::LightsailClient::DeleteRelationalDatabaseSnapshot ( const Model::DeleteRelationalDatabaseSnapshotRequest request) const
virtual

Deletes a database snapshot in Amazon Lightsail.

The delete relational database snapshot operation supports tag-based access control via resource tags applied to the resource identified by relationalDatabaseName. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ DeleteRelationalDatabaseSnapshotAsync()

template<typename DeleteRelationalDatabaseSnapshotRequestT = Model::DeleteRelationalDatabaseSnapshotRequest>
void Aws::Lightsail::LightsailClient::DeleteRelationalDatabaseSnapshotAsync ( const DeleteRelationalDatabaseSnapshotRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteRelationalDatabaseSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1765 of file LightsailClient.h.

◆ DeleteRelationalDatabaseSnapshotCallable()

template<typename DeleteRelationalDatabaseSnapshotRequestT = Model::DeleteRelationalDatabaseSnapshotRequest>
Model::DeleteRelationalDatabaseSnapshotOutcomeCallable Aws::Lightsail::LightsailClient::DeleteRelationalDatabaseSnapshotCallable ( const DeleteRelationalDatabaseSnapshotRequestT &  request) const
inline

A Callable wrapper for DeleteRelationalDatabaseSnapshot that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1756 of file LightsailClient.h.

◆ DetachCertificateFromDistribution()

virtual Model::DetachCertificateFromDistributionOutcome Aws::Lightsail::LightsailClient::DetachCertificateFromDistribution ( const Model::DetachCertificateFromDistributionRequest request) const
virtual

Detaches an SSL/TLS certificate from your Amazon Lightsail content delivery network (CDN) distribution.

After the certificate is detached, your distribution stops accepting traffic for all of the domains that are associated with the certificate.

See Also:

AWS API Reference

◆ DetachCertificateFromDistributionAsync()

template<typename DetachCertificateFromDistributionRequestT = Model::DetachCertificateFromDistributionRequest>
void Aws::Lightsail::LightsailClient::DetachCertificateFromDistributionAsync ( const DetachCertificateFromDistributionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DetachCertificateFromDistribution that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1793 of file LightsailClient.h.

◆ DetachCertificateFromDistributionCallable()

template<typename DetachCertificateFromDistributionRequestT = Model::DetachCertificateFromDistributionRequest>
Model::DetachCertificateFromDistributionOutcomeCallable Aws::Lightsail::LightsailClient::DetachCertificateFromDistributionCallable ( const DetachCertificateFromDistributionRequestT &  request) const
inline

A Callable wrapper for DetachCertificateFromDistribution that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1784 of file LightsailClient.h.

◆ DetachDisk()

virtual Model::DetachDiskOutcome Aws::Lightsail::LightsailClient::DetachDisk ( const Model::DetachDiskRequest request) const
virtual

Detaches a stopped block storage disk from a Lightsail instance. Make sure to unmount any file systems on the device within your operating system before stopping the instance and detaching the disk.

The detach disk operation supports tag-based access control via resource tags applied to the resource identified by disk name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ DetachDiskAsync()

template<typename DetachDiskRequestT = Model::DetachDiskRequest>
void Aws::Lightsail::LightsailClient::DetachDiskAsync ( const DetachDiskRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DetachDisk that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1825 of file LightsailClient.h.

◆ DetachDiskCallable()

template<typename DetachDiskRequestT = Model::DetachDiskRequest>
Model::DetachDiskOutcomeCallable Aws::Lightsail::LightsailClient::DetachDiskCallable ( const DetachDiskRequestT &  request) const
inline

A Callable wrapper for DetachDisk that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1816 of file LightsailClient.h.

◆ DetachInstancesFromLoadBalancer()

virtual Model::DetachInstancesFromLoadBalancerOutcome Aws::Lightsail::LightsailClient::DetachInstancesFromLoadBalancer ( const Model::DetachInstancesFromLoadBalancerRequest request) const
virtual

Detaches the specified instances from a Lightsail load balancer.

This operation waits until the instances are no longer needed before they are detached from the load balancer.

The detach instances from load balancer operation supports tag-based access control via resource tags applied to the resource identified by load balancer name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ DetachInstancesFromLoadBalancerAsync()

template<typename DetachInstancesFromLoadBalancerRequestT = Model::DetachInstancesFromLoadBalancerRequest>
void Aws::Lightsail::LightsailClient::DetachInstancesFromLoadBalancerAsync ( const DetachInstancesFromLoadBalancerRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DetachInstancesFromLoadBalancer that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1857 of file LightsailClient.h.

◆ DetachInstancesFromLoadBalancerCallable()

template<typename DetachInstancesFromLoadBalancerRequestT = Model::DetachInstancesFromLoadBalancerRequest>
Model::DetachInstancesFromLoadBalancerOutcomeCallable Aws::Lightsail::LightsailClient::DetachInstancesFromLoadBalancerCallable ( const DetachInstancesFromLoadBalancerRequestT &  request) const
inline

A Callable wrapper for DetachInstancesFromLoadBalancer that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1848 of file LightsailClient.h.

◆ DetachStaticIp()

virtual Model::DetachStaticIpOutcome Aws::Lightsail::LightsailClient::DetachStaticIp ( const Model::DetachStaticIpRequest request) const
virtual

Detaches a static IP from the Amazon Lightsail instance to which it is attached.

See Also:

AWS API Reference

◆ DetachStaticIpAsync()

template<typename DetachStaticIpRequestT = Model::DetachStaticIpRequest>
void Aws::Lightsail::LightsailClient::DetachStaticIpAsync ( const DetachStaticIpRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DetachStaticIp that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1883 of file LightsailClient.h.

◆ DetachStaticIpCallable()

template<typename DetachStaticIpRequestT = Model::DetachStaticIpRequest>
Model::DetachStaticIpOutcomeCallable Aws::Lightsail::LightsailClient::DetachStaticIpCallable ( const DetachStaticIpRequestT &  request) const
inline

A Callable wrapper for DetachStaticIp that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1874 of file LightsailClient.h.

◆ DisableAddOn()

virtual Model::DisableAddOnOutcome Aws::Lightsail::LightsailClient::DisableAddOn ( const Model::DisableAddOnRequest request) const
virtual

Disables an add-on for an Amazon Lightsail resource. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ DisableAddOnAsync()

template<typename DisableAddOnRequestT = Model::DisableAddOnRequest>
void Aws::Lightsail::LightsailClient::DisableAddOnAsync ( const DisableAddOnRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DisableAddOn that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1911 of file LightsailClient.h.

◆ DisableAddOnCallable()

template<typename DisableAddOnRequestT = Model::DisableAddOnRequest>
Model::DisableAddOnOutcomeCallable Aws::Lightsail::LightsailClient::DisableAddOnCallable ( const DisableAddOnRequestT &  request) const
inline

A Callable wrapper for DisableAddOn that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1902 of file LightsailClient.h.

◆ DownloadDefaultKeyPair()

virtual Model::DownloadDefaultKeyPairOutcome Aws::Lightsail::LightsailClient::DownloadDefaultKeyPair ( const Model::DownloadDefaultKeyPairRequest request = {}) const
virtual

Downloads the regional Amazon Lightsail default key pair.

This action also creates a Lightsail default key pair if a default key pair does not currently exist in the Amazon Web Services Region.

See Also:

AWS API Reference

◆ DownloadDefaultKeyPairAsync()

template<typename DownloadDefaultKeyPairRequestT = Model::DownloadDefaultKeyPairRequest>
void Aws::Lightsail::LightsailClient::DownloadDefaultKeyPairAsync ( const DownloadDefaultKeyPairResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const DownloadDefaultKeyPairRequestT &  request = {} 
) const
inline

An Async wrapper for DownloadDefaultKeyPair that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1938 of file LightsailClient.h.

◆ DownloadDefaultKeyPairCallable()

template<typename DownloadDefaultKeyPairRequestT = Model::DownloadDefaultKeyPairRequest>
Model::DownloadDefaultKeyPairOutcomeCallable Aws::Lightsail::LightsailClient::DownloadDefaultKeyPairCallable ( const DownloadDefaultKeyPairRequestT &  request = {}) const
inline

A Callable wrapper for DownloadDefaultKeyPair that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1929 of file LightsailClient.h.

◆ EnableAddOn()

virtual Model::EnableAddOnOutcome Aws::Lightsail::LightsailClient::EnableAddOn ( const Model::EnableAddOnRequest request) const
virtual

Enables or modifies an add-on for an Amazon Lightsail resource. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ EnableAddOnAsync()

template<typename EnableAddOnRequestT = Model::EnableAddOnRequest>
void Aws::Lightsail::LightsailClient::EnableAddOnAsync ( const EnableAddOnRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for EnableAddOn that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1966 of file LightsailClient.h.

◆ EnableAddOnCallable()

template<typename EnableAddOnRequestT = Model::EnableAddOnRequest>
Model::EnableAddOnOutcomeCallable Aws::Lightsail::LightsailClient::EnableAddOnCallable ( const EnableAddOnRequestT &  request) const
inline

A Callable wrapper for EnableAddOn that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1957 of file LightsailClient.h.

◆ ExportSnapshot()

virtual Model::ExportSnapshotOutcome Aws::Lightsail::LightsailClient::ExportSnapshot ( const Model::ExportSnapshotRequest request) const
virtual

Exports an Amazon Lightsail instance or block storage disk snapshot to Amazon Elastic Compute Cloud (Amazon EC2). This operation results in an export snapshot record that can be used with the create cloud formation stack operation to create new Amazon EC2 instances.

Exported instance snapshots appear in Amazon EC2 as Amazon Machine Images (AMIs), and the instance system disk appears as an Amazon Elastic Block Store (Amazon EBS) volume. Exported disk snapshots appear in Amazon EC2 as Amazon EBS volumes. Snapshots are exported to the same Amazon Web Services Region in Amazon EC2 as the source Lightsail snapshot.

The export snapshot operation supports tag-based access control via resource tags applied to the resource identified by source snapshot name. For more information, see the Amazon Lightsail Developer Guide.

Use the get instance snapshots or get disk snapshots operations to get a list of snapshots that you can export to Amazon EC2.

See Also:


AWS API Reference

◆ ExportSnapshotAsync()

template<typename ExportSnapshotRequestT = Model::ExportSnapshotRequest>
void Aws::Lightsail::LightsailClient::ExportSnapshotAsync ( const ExportSnapshotRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ExportSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2006 of file LightsailClient.h.

◆ ExportSnapshotCallable()

template<typename ExportSnapshotRequestT = Model::ExportSnapshotRequest>
Model::ExportSnapshotOutcomeCallable Aws::Lightsail::LightsailClient::ExportSnapshotCallable ( const ExportSnapshotRequestT &  request) const
inline

A Callable wrapper for ExportSnapshot that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1997 of file LightsailClient.h.

◆ GetActiveNames()

virtual Model::GetActiveNamesOutcome Aws::Lightsail::LightsailClient::GetActiveNames ( const Model::GetActiveNamesRequest request = {}) const
virtual

Returns the names of all active (not deleted) resources.

See Also:

AWS API Reference

◆ GetActiveNamesAsync()

template<typename GetActiveNamesRequestT = Model::GetActiveNamesRequest>
void Aws::Lightsail::LightsailClient::GetActiveNamesAsync ( const GetActiveNamesResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetActiveNamesRequestT &  request = {} 
) const
inline

An Async wrapper for GetActiveNames that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2032 of file LightsailClient.h.

◆ GetActiveNamesCallable()

template<typename GetActiveNamesRequestT = Model::GetActiveNamesRequest>
Model::GetActiveNamesOutcomeCallable Aws::Lightsail::LightsailClient::GetActiveNamesCallable ( const GetActiveNamesRequestT &  request = {}) const
inline

A Callable wrapper for GetActiveNames that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2023 of file LightsailClient.h.

◆ GetAlarms()

virtual Model::GetAlarmsOutcome Aws::Lightsail::LightsailClient::GetAlarms ( const Model::GetAlarmsRequest request = {}) const
virtual

Returns information about the configured alarms. Specify an alarm name in your request to return information about a specific alarm, or specify a monitored resource name to return information about all alarms for a specific resource.

An alarm is used to monitor a single metric for one of your resources. When a metric condition is met, the alarm can notify you by email, SMS text message, and a banner displayed on the Amazon Lightsail console. For more information, see Alarms in Amazon Lightsail.

See Also:

AWS API Reference

◆ GetAlarmsAsync()

template<typename GetAlarmsRequestT = Model::GetAlarmsRequest>
void Aws::Lightsail::LightsailClient::GetAlarmsAsync ( const GetAlarmsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetAlarmsRequestT &  request = {} 
) const
inline

An Async wrapper for GetAlarms that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2065 of file LightsailClient.h.

◆ GetAlarmsCallable()

template<typename GetAlarmsRequestT = Model::GetAlarmsRequest>
Model::GetAlarmsOutcomeCallable Aws::Lightsail::LightsailClient::GetAlarmsCallable ( const GetAlarmsRequestT &  request = {}) const
inline

A Callable wrapper for GetAlarms that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2056 of file LightsailClient.h.

◆ GetAllocationTag()

static const char * Aws::Lightsail::LightsailClient::GetAllocationTag ( )
static

◆ GetAutoSnapshots()

virtual Model::GetAutoSnapshotsOutcome Aws::Lightsail::LightsailClient::GetAutoSnapshots ( const Model::GetAutoSnapshotsRequest request) const
virtual

Returns the available automatic snapshots for an instance or disk. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ GetAutoSnapshotsAsync()

template<typename GetAutoSnapshotsRequestT = Model::GetAutoSnapshotsRequest>
void Aws::Lightsail::LightsailClient::GetAutoSnapshotsAsync ( const GetAutoSnapshotsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetAutoSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2093 of file LightsailClient.h.

◆ GetAutoSnapshotsCallable()

template<typename GetAutoSnapshotsRequestT = Model::GetAutoSnapshotsRequest>
Model::GetAutoSnapshotsOutcomeCallable Aws::Lightsail::LightsailClient::GetAutoSnapshotsCallable ( const GetAutoSnapshotsRequestT &  request) const
inline

A Callable wrapper for GetAutoSnapshots that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2084 of file LightsailClient.h.

◆ GetBlueprints()

virtual Model::GetBlueprintsOutcome Aws::Lightsail::LightsailClient::GetBlueprints ( const Model::GetBlueprintsRequest request = {}) const
virtual

Returns the list of available instance images, or blueprints. You can use a blueprint to create a new instance already running a specific operating system, as well as a preinstalled app or development stack. The software each instance is running depends on the blueprint image you choose.

Use active blueprints when creating new instances. Inactive blueprints are listed to support customers with existing instances and are not necessarily available to create new instances. Blueprints are marked inactive when they become outdated due to operating system updates or new application releases.

See Also:

AWS API Reference

◆ GetBlueprintsAsync()

template<typename GetBlueprintsRequestT = Model::GetBlueprintsRequest>
void Aws::Lightsail::LightsailClient::GetBlueprintsAsync ( const GetBlueprintsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetBlueprintsRequestT &  request = {} 
) const
inline

An Async wrapper for GetBlueprints that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2126 of file LightsailClient.h.

◆ GetBlueprintsCallable()

template<typename GetBlueprintsRequestT = Model::GetBlueprintsRequest>
Model::GetBlueprintsOutcomeCallable Aws::Lightsail::LightsailClient::GetBlueprintsCallable ( const GetBlueprintsRequestT &  request = {}) const
inline

A Callable wrapper for GetBlueprints that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2117 of file LightsailClient.h.

◆ GetBucketAccessKeys()

virtual Model::GetBucketAccessKeysOutcome Aws::Lightsail::LightsailClient::GetBucketAccessKeys ( const Model::GetBucketAccessKeysRequest request) const
virtual

Returns the existing access key IDs for the specified Amazon Lightsail bucket.

This action does not return the secret access key value of an access key. You can get a secret access key only when you create it from the response of the CreateBucketAccessKey action. If you lose the secret access key, you must create a new access key.

See Also:

AWS API Reference

◆ GetBucketAccessKeysAsync()

template<typename GetBucketAccessKeysRequestT = Model::GetBucketAccessKeysRequest>
void Aws::Lightsail::LightsailClient::GetBucketAccessKeysAsync ( const GetBucketAccessKeysRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetBucketAccessKeys that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2157 of file LightsailClient.h.

◆ GetBucketAccessKeysCallable()

template<typename GetBucketAccessKeysRequestT = Model::GetBucketAccessKeysRequest>
Model::GetBucketAccessKeysOutcomeCallable Aws::Lightsail::LightsailClient::GetBucketAccessKeysCallable ( const GetBucketAccessKeysRequestT &  request) const
inline

A Callable wrapper for GetBucketAccessKeys that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2148 of file LightsailClient.h.

◆ GetBucketBundles()

virtual Model::GetBucketBundlesOutcome Aws::Lightsail::LightsailClient::GetBucketBundles ( const Model::GetBucketBundlesRequest request = {}) const
virtual

Returns the bundles that you can apply to a Amazon Lightsail bucket.

The bucket bundle specifies the monthly cost, storage quota, and data transfer quota for a bucket.

Use the UpdateBucketBundle action to update the bundle for a bucket.

See Also:

AWS API Reference

◆ GetBucketBundlesAsync()

template<typename GetBucketBundlesRequestT = Model::GetBucketBundlesRequest>
void Aws::Lightsail::LightsailClient::GetBucketBundlesAsync ( const GetBucketBundlesResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetBucketBundlesRequestT &  request = {} 
) const
inline

An Async wrapper for GetBucketBundles that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2186 of file LightsailClient.h.

◆ GetBucketBundlesCallable()

template<typename GetBucketBundlesRequestT = Model::GetBucketBundlesRequest>
Model::GetBucketBundlesOutcomeCallable Aws::Lightsail::LightsailClient::GetBucketBundlesCallable ( const GetBucketBundlesRequestT &  request = {}) const
inline

A Callable wrapper for GetBucketBundles that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2177 of file LightsailClient.h.

◆ GetBucketMetricData()

virtual Model::GetBucketMetricDataOutcome Aws::Lightsail::LightsailClient::GetBucketMetricData ( const Model::GetBucketMetricDataRequest request) const
virtual

Returns the data points of a specific metric for an Amazon Lightsail bucket.

Metrics report the utilization of a bucket. View and collect metric data regularly to monitor the number of objects stored in a bucket (including object versions) and the storage space used by those objects.

See Also:

AWS API Reference

◆ GetBucketMetricDataAsync()

template<typename GetBucketMetricDataRequestT = Model::GetBucketMetricDataRequest>
void Aws::Lightsail::LightsailClient::GetBucketMetricDataAsync ( const GetBucketMetricDataRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetBucketMetricData that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2215 of file LightsailClient.h.

◆ GetBucketMetricDataCallable()

template<typename GetBucketMetricDataRequestT = Model::GetBucketMetricDataRequest>
Model::GetBucketMetricDataOutcomeCallable Aws::Lightsail::LightsailClient::GetBucketMetricDataCallable ( const GetBucketMetricDataRequestT &  request) const
inline

A Callable wrapper for GetBucketMetricData that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2206 of file LightsailClient.h.

◆ GetBuckets()

virtual Model::GetBucketsOutcome Aws::Lightsail::LightsailClient::GetBuckets ( const Model::GetBucketsRequest request = {}) const
virtual

Returns information about one or more Amazon Lightsail buckets. The information returned includes the synchronization status of the Amazon Simple Storage Service (Amazon S3) account-level block public access feature for your Lightsail buckets.

For more information about buckets, see Buckets in Amazon Lightsail in the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ GetBucketsAsync()

template<typename GetBucketsRequestT = Model::GetBucketsRequest>
void Aws::Lightsail::LightsailClient::GetBucketsAsync ( const GetBucketsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetBucketsRequestT &  request = {} 
) const
inline

An Async wrapper for GetBuckets that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2246 of file LightsailClient.h.

◆ GetBucketsCallable()

template<typename GetBucketsRequestT = Model::GetBucketsRequest>
Model::GetBucketsOutcomeCallable Aws::Lightsail::LightsailClient::GetBucketsCallable ( const GetBucketsRequestT &  request = {}) const
inline

A Callable wrapper for GetBuckets that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2237 of file LightsailClient.h.

◆ GetBundles()

virtual Model::GetBundlesOutcome Aws::Lightsail::LightsailClient::GetBundles ( const Model::GetBundlesRequest request = {}) const
virtual

Returns the bundles that you can apply to an Amazon Lightsail instance when you create it.

A bundle describes the specifications of an instance, such as the monthly cost, amount of memory, the number of vCPUs, amount of storage space, and monthly network data transfer quota.

Bundles are referred to as instance plans in the Lightsail console.

See Also:

AWS API Reference

◆ GetBundlesAsync()

template<typename GetBundlesRequestT = Model::GetBundlesRequest>
void Aws::Lightsail::LightsailClient::GetBundlesAsync ( const GetBundlesResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetBundlesRequestT &  request = {} 
) const
inline

An Async wrapper for GetBundles that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2276 of file LightsailClient.h.

◆ GetBundlesCallable()

template<typename GetBundlesRequestT = Model::GetBundlesRequest>
Model::GetBundlesOutcomeCallable Aws::Lightsail::LightsailClient::GetBundlesCallable ( const GetBundlesRequestT &  request = {}) const
inline

A Callable wrapper for GetBundles that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2267 of file LightsailClient.h.

◆ GetCertificates()

virtual Model::GetCertificatesOutcome Aws::Lightsail::LightsailClient::GetCertificates ( const Model::GetCertificatesRequest request = {}) const
virtual

Returns information about one or more Amazon Lightsail SSL/TLS certificates.

To get a summary of a certificate, omit includeCertificateDetails from your request. The response will include only the certificate Amazon Resource Name (ARN), certificate name, domain name, and tags.

See Also:

AWS API Reference

◆ GetCertificatesAsync()

template<typename GetCertificatesRequestT = Model::GetCertificatesRequest>
void Aws::Lightsail::LightsailClient::GetCertificatesAsync ( const GetCertificatesResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetCertificatesRequestT &  request = {} 
) const
inline

An Async wrapper for GetCertificates that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2305 of file LightsailClient.h.

◆ GetCertificatesCallable()

template<typename GetCertificatesRequestT = Model::GetCertificatesRequest>
Model::GetCertificatesOutcomeCallable Aws::Lightsail::LightsailClient::GetCertificatesCallable ( const GetCertificatesRequestT &  request = {}) const
inline

A Callable wrapper for GetCertificates that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2296 of file LightsailClient.h.

◆ GetCloudFormationStackRecords()

virtual Model::GetCloudFormationStackRecordsOutcome Aws::Lightsail::LightsailClient::GetCloudFormationStackRecords ( const Model::GetCloudFormationStackRecordsRequest request = {}) const
virtual

Returns the CloudFormation stack record created as a result of the create cloud formation stack operation.

An AWS CloudFormation stack is used to create a new Amazon EC2 instance from an exported Lightsail snapshot.

See Also:

AWS API Reference

◆ GetCloudFormationStackRecordsAsync()

template<typename GetCloudFormationStackRecordsRequestT = Model::GetCloudFormationStackRecordsRequest>
void Aws::Lightsail::LightsailClient::GetCloudFormationStackRecordsAsync ( const GetCloudFormationStackRecordsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetCloudFormationStackRecordsRequestT &  request = {} 
) const
inline

An Async wrapper for GetCloudFormationStackRecords that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2333 of file LightsailClient.h.

◆ GetCloudFormationStackRecordsCallable()

template<typename GetCloudFormationStackRecordsRequestT = Model::GetCloudFormationStackRecordsRequest>
Model::GetCloudFormationStackRecordsOutcomeCallable Aws::Lightsail::LightsailClient::GetCloudFormationStackRecordsCallable ( const GetCloudFormationStackRecordsRequestT &  request = {}) const
inline

A Callable wrapper for GetCloudFormationStackRecords that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2324 of file LightsailClient.h.

◆ GetContactMethods()

virtual Model::GetContactMethodsOutcome Aws::Lightsail::LightsailClient::GetContactMethods ( const Model::GetContactMethodsRequest request = {}) const
virtual

Returns information about the configured contact methods. Specify a protocol in your request to return information about a specific contact method.

A contact method is used to send you notifications about your Amazon Lightsail resources. You can add one email address and one mobile phone number contact method in each Amazon Web Services Region. However, SMS text messaging is not supported in some Amazon Web Services Regions, and SMS text messages cannot be sent to some countries/regions. For more information, see Notifications in Amazon Lightsail.

See Also:

AWS API Reference

◆ GetContactMethodsAsync()

template<typename GetContactMethodsRequestT = Model::GetContactMethodsRequest>
void Aws::Lightsail::LightsailClient::GetContactMethodsAsync ( const GetContactMethodsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetContactMethodsRequestT &  request = {} 
) const
inline

An Async wrapper for GetContactMethods that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2366 of file LightsailClient.h.

◆ GetContactMethodsCallable()

template<typename GetContactMethodsRequestT = Model::GetContactMethodsRequest>
Model::GetContactMethodsOutcomeCallable Aws::Lightsail::LightsailClient::GetContactMethodsCallable ( const GetContactMethodsRequestT &  request = {}) const
inline

A Callable wrapper for GetContactMethods that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2357 of file LightsailClient.h.

◆ GetContainerAPIMetadata()

virtual Model::GetContainerAPIMetadataOutcome Aws::Lightsail::LightsailClient::GetContainerAPIMetadata ( const Model::GetContainerAPIMetadataRequest request = {}) const
virtual

Returns information about Amazon Lightsail containers, such as the current version of the Lightsail Control (lightsailctl) plugin.

See Also:

AWS API Reference

◆ GetContainerAPIMetadataAsync()

template<typename GetContainerAPIMetadataRequestT = Model::GetContainerAPIMetadataRequest>
void Aws::Lightsail::LightsailClient::GetContainerAPIMetadataAsync ( const GetContainerAPIMetadataResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetContainerAPIMetadataRequestT &  request = {} 
) const
inline

An Async wrapper for GetContainerAPIMetadata that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2393 of file LightsailClient.h.

◆ GetContainerAPIMetadataCallable()

template<typename GetContainerAPIMetadataRequestT = Model::GetContainerAPIMetadataRequest>
Model::GetContainerAPIMetadataOutcomeCallable Aws::Lightsail::LightsailClient::GetContainerAPIMetadataCallable ( const GetContainerAPIMetadataRequestT &  request = {}) const
inline

A Callable wrapper for GetContainerAPIMetadata that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2384 of file LightsailClient.h.

◆ GetContainerImages()

virtual Model::GetContainerImagesOutcome Aws::Lightsail::LightsailClient::GetContainerImages ( const Model::GetContainerImagesRequest request) const
virtual

Returns the container images that are registered to your Amazon Lightsail container service.

If you created a deployment on your Lightsail container service that uses container images from a public registry like Docker Hub, those images are not returned as part of this action. Those images are not registered to your Lightsail container service.

See Also:

AWS API Reference

◆ GetContainerImagesAsync()

template<typename GetContainerImagesRequestT = Model::GetContainerImagesRequest>
void Aws::Lightsail::LightsailClient::GetContainerImagesAsync ( const GetContainerImagesRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetContainerImages that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2423 of file LightsailClient.h.

◆ GetContainerImagesCallable()

template<typename GetContainerImagesRequestT = Model::GetContainerImagesRequest>
Model::GetContainerImagesOutcomeCallable Aws::Lightsail::LightsailClient::GetContainerImagesCallable ( const GetContainerImagesRequestT &  request) const
inline

A Callable wrapper for GetContainerImages that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2414 of file LightsailClient.h.

◆ GetContainerLog()

virtual Model::GetContainerLogOutcome Aws::Lightsail::LightsailClient::GetContainerLog ( const Model::GetContainerLogRequest request) const
virtual

Returns the log events of a container of your Amazon Lightsail container service.

If your container service has more than one node (i.e., a scale greater than 1), then the log events that are returned for the specified container are merged from all nodes on your container service.

Container logs are retained for a certain amount of time. For more information, see Amazon Lightsail endpoints and quotas in the Amazon Web Services General Reference.

See Also:

AWS API Reference

◆ GetContainerLogAsync()

template<typename GetContainerLogRequestT = Model::GetContainerLogRequest>
void Aws::Lightsail::LightsailClient::GetContainerLogAsync ( const GetContainerLogRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetContainerLog that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2456 of file LightsailClient.h.

◆ GetContainerLogCallable()

template<typename GetContainerLogRequestT = Model::GetContainerLogRequest>
Model::GetContainerLogOutcomeCallable Aws::Lightsail::LightsailClient::GetContainerLogCallable ( const GetContainerLogRequestT &  request) const
inline

A Callable wrapper for GetContainerLog that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2447 of file LightsailClient.h.

◆ GetContainerServiceDeployments()

virtual Model::GetContainerServiceDeploymentsOutcome Aws::Lightsail::LightsailClient::GetContainerServiceDeployments ( const Model::GetContainerServiceDeploymentsRequest request) const
virtual

Returns the deployments for your Amazon Lightsail container service

A deployment specifies the settings, such as the ports and launch command, of containers that are deployed to your container service.

The deployments are ordered by version in ascending order. The newest version is listed at the top of the response.

A set number of deployments are kept before the oldest one is replaced with the newest one. For more information, see Amazon Lightsail endpoints and quotas in the Amazon Web Services General Reference.

See Also:

AWS API Reference

◆ GetContainerServiceDeploymentsAsync()

template<typename GetContainerServiceDeploymentsRequestT = Model::GetContainerServiceDeploymentsRequest>
void Aws::Lightsail::LightsailClient::GetContainerServiceDeploymentsAsync ( const GetContainerServiceDeploymentsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetContainerServiceDeployments that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2489 of file LightsailClient.h.

◆ GetContainerServiceDeploymentsCallable()

template<typename GetContainerServiceDeploymentsRequestT = Model::GetContainerServiceDeploymentsRequest>
Model::GetContainerServiceDeploymentsOutcomeCallable Aws::Lightsail::LightsailClient::GetContainerServiceDeploymentsCallable ( const GetContainerServiceDeploymentsRequestT &  request) const
inline

A Callable wrapper for GetContainerServiceDeployments that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2480 of file LightsailClient.h.

◆ GetContainerServiceMetricData()

virtual Model::GetContainerServiceMetricDataOutcome Aws::Lightsail::LightsailClient::GetContainerServiceMetricData ( const Model::GetContainerServiceMetricDataRequest request) const
virtual

Returns the data points of a specific metric of your Amazon Lightsail container service.

Metrics report the utilization of your resources. Monitor and collect metric data regularly to maintain the reliability, availability, and performance of your resources.

See Also:

AWS API Reference

◆ GetContainerServiceMetricDataAsync()

template<typename GetContainerServiceMetricDataRequestT = Model::GetContainerServiceMetricDataRequest>
void Aws::Lightsail::LightsailClient::GetContainerServiceMetricDataAsync ( const GetContainerServiceMetricDataRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetContainerServiceMetricData that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2517 of file LightsailClient.h.

◆ GetContainerServiceMetricDataCallable()

template<typename GetContainerServiceMetricDataRequestT = Model::GetContainerServiceMetricDataRequest>
Model::GetContainerServiceMetricDataOutcomeCallable Aws::Lightsail::LightsailClient::GetContainerServiceMetricDataCallable ( const GetContainerServiceMetricDataRequestT &  request) const
inline

A Callable wrapper for GetContainerServiceMetricData that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2508 of file LightsailClient.h.

◆ GetContainerServicePowers()

virtual Model::GetContainerServicePowersOutcome Aws::Lightsail::LightsailClient::GetContainerServicePowers ( const Model::GetContainerServicePowersRequest request = {}) const
virtual

Returns the list of powers that can be specified for your Amazon Lightsail container services.

The power specifies the amount of memory, the number of vCPUs, and the base price of the container service.

See Also:

AWS API Reference

◆ GetContainerServicePowersAsync()

template<typename GetContainerServicePowersRequestT = Model::GetContainerServicePowersRequest>
void Aws::Lightsail::LightsailClient::GetContainerServicePowersAsync ( const GetContainerServicePowersResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetContainerServicePowersRequestT &  request = {} 
) const
inline

An Async wrapper for GetContainerServicePowers that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2545 of file LightsailClient.h.

◆ GetContainerServicePowersCallable()

template<typename GetContainerServicePowersRequestT = Model::GetContainerServicePowersRequest>
Model::GetContainerServicePowersOutcomeCallable Aws::Lightsail::LightsailClient::GetContainerServicePowersCallable ( const GetContainerServicePowersRequestT &  request = {}) const
inline

A Callable wrapper for GetContainerServicePowers that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2536 of file LightsailClient.h.

◆ GetContainerServices()

virtual Model::GetContainerServicesOutcome Aws::Lightsail::LightsailClient::GetContainerServices ( const Model::GetContainerServicesRequest request = {}) const
virtual

Returns information about one or more of your Amazon Lightsail container services.

See Also:

AWS API Reference

◆ GetContainerServicesAsync()

template<typename GetContainerServicesRequestT = Model::GetContainerServicesRequest>
void Aws::Lightsail::LightsailClient::GetContainerServicesAsync ( const GetContainerServicesResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetContainerServicesRequestT &  request = {} 
) const
inline

An Async wrapper for GetContainerServices that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2571 of file LightsailClient.h.

◆ GetContainerServicesCallable()

template<typename GetContainerServicesRequestT = Model::GetContainerServicesRequest>
Model::GetContainerServicesOutcomeCallable Aws::Lightsail::LightsailClient::GetContainerServicesCallable ( const GetContainerServicesRequestT &  request = {}) const
inline

A Callable wrapper for GetContainerServices that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2562 of file LightsailClient.h.

◆ GetCostEstimate()

virtual Model::GetCostEstimateOutcome Aws::Lightsail::LightsailClient::GetCostEstimate ( const Model::GetCostEstimateRequest request) const
virtual

Retrieves information about the cost estimate for a specified resource. A cost estimate will not generate for a resource that has been deleted.

See Also:

AWS API Reference

◆ GetCostEstimateAsync()

template<typename GetCostEstimateRequestT = Model::GetCostEstimateRequest>
void Aws::Lightsail::LightsailClient::GetCostEstimateAsync ( const GetCostEstimateRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetCostEstimate that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2598 of file LightsailClient.h.

◆ GetCostEstimateCallable()

template<typename GetCostEstimateRequestT = Model::GetCostEstimateRequest>
Model::GetCostEstimateOutcomeCallable Aws::Lightsail::LightsailClient::GetCostEstimateCallable ( const GetCostEstimateRequestT &  request) const
inline

A Callable wrapper for GetCostEstimate that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2589 of file LightsailClient.h.

◆ GetDisk()

virtual Model::GetDiskOutcome Aws::Lightsail::LightsailClient::GetDisk ( const Model::GetDiskRequest request) const
virtual

Returns information about a specific block storage disk.

See Also:

AWS API Reference

◆ GetDiskAsync()

template<typename GetDiskRequestT = Model::GetDiskRequest>
void Aws::Lightsail::LightsailClient::GetDiskAsync ( const GetDiskRequestT &  request,
const GetDiskResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetDisk that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2624 of file LightsailClient.h.

◆ GetDiskCallable()

template<typename GetDiskRequestT = Model::GetDiskRequest>
Model::GetDiskOutcomeCallable Aws::Lightsail::LightsailClient::GetDiskCallable ( const GetDiskRequestT &  request) const
inline

A Callable wrapper for GetDisk that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2615 of file LightsailClient.h.

◆ GetDisks()

virtual Model::GetDisksOutcome Aws::Lightsail::LightsailClient::GetDisks ( const Model::GetDisksRequest request = {}) const
virtual

Returns information about all block storage disks in your AWS account and region.

See Also:

AWS API Reference

◆ GetDisksAsync()

template<typename GetDisksRequestT = Model::GetDisksRequest>
void Aws::Lightsail::LightsailClient::GetDisksAsync ( const GetDisksResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetDisksRequestT &  request = {} 
) const
inline

An Async wrapper for GetDisks that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2702 of file LightsailClient.h.

◆ GetDisksCallable()

template<typename GetDisksRequestT = Model::GetDisksRequest>
Model::GetDisksOutcomeCallable Aws::Lightsail::LightsailClient::GetDisksCallable ( const GetDisksRequestT &  request = {}) const
inline

A Callable wrapper for GetDisks that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2693 of file LightsailClient.h.

◆ GetDiskSnapshot()

virtual Model::GetDiskSnapshotOutcome Aws::Lightsail::LightsailClient::GetDiskSnapshot ( const Model::GetDiskSnapshotRequest request) const
virtual

Returns information about a specific block storage disk snapshot.

See Also:

AWS API Reference

◆ GetDiskSnapshotAsync()

template<typename GetDiskSnapshotRequestT = Model::GetDiskSnapshotRequest>
void Aws::Lightsail::LightsailClient::GetDiskSnapshotAsync ( const GetDiskSnapshotRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetDiskSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2650 of file LightsailClient.h.

◆ GetDiskSnapshotCallable()

template<typename GetDiskSnapshotRequestT = Model::GetDiskSnapshotRequest>
Model::GetDiskSnapshotOutcomeCallable Aws::Lightsail::LightsailClient::GetDiskSnapshotCallable ( const GetDiskSnapshotRequestT &  request) const
inline

A Callable wrapper for GetDiskSnapshot that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2641 of file LightsailClient.h.

◆ GetDiskSnapshots()

virtual Model::GetDiskSnapshotsOutcome Aws::Lightsail::LightsailClient::GetDiskSnapshots ( const Model::GetDiskSnapshotsRequest request = {}) const
virtual

Returns information about all block storage disk snapshots in your AWS account and region.

See Also:

AWS API Reference

◆ GetDiskSnapshotsAsync()

template<typename GetDiskSnapshotsRequestT = Model::GetDiskSnapshotsRequest>
void Aws::Lightsail::LightsailClient::GetDiskSnapshotsAsync ( const GetDiskSnapshotsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetDiskSnapshotsRequestT &  request = {} 
) const
inline

An Async wrapper for GetDiskSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2676 of file LightsailClient.h.

◆ GetDiskSnapshotsCallable()

template<typename GetDiskSnapshotsRequestT = Model::GetDiskSnapshotsRequest>
Model::GetDiskSnapshotsOutcomeCallable Aws::Lightsail::LightsailClient::GetDiskSnapshotsCallable ( const GetDiskSnapshotsRequestT &  request = {}) const
inline

A Callable wrapper for GetDiskSnapshots that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2667 of file LightsailClient.h.

◆ GetDistributionBundles()

virtual Model::GetDistributionBundlesOutcome Aws::Lightsail::LightsailClient::GetDistributionBundles ( const Model::GetDistributionBundlesRequest request = {}) const
virtual

Returns the bundles that can be applied to your Amazon Lightsail content delivery network (CDN) distributions.

A distribution bundle specifies the monthly network transfer quota and monthly cost of your distribution.

See Also:

AWS API Reference

◆ GetDistributionBundlesAsync()

template<typename GetDistributionBundlesRequestT = Model::GetDistributionBundlesRequest>
void Aws::Lightsail::LightsailClient::GetDistributionBundlesAsync ( const GetDistributionBundlesResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetDistributionBundlesRequestT &  request = {} 
) const
inline

An Async wrapper for GetDistributionBundles that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2730 of file LightsailClient.h.

◆ GetDistributionBundlesCallable()

template<typename GetDistributionBundlesRequestT = Model::GetDistributionBundlesRequest>
Model::GetDistributionBundlesOutcomeCallable Aws::Lightsail::LightsailClient::GetDistributionBundlesCallable ( const GetDistributionBundlesRequestT &  request = {}) const
inline

A Callable wrapper for GetDistributionBundles that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2721 of file LightsailClient.h.

◆ GetDistributionLatestCacheReset()

virtual Model::GetDistributionLatestCacheResetOutcome Aws::Lightsail::LightsailClient::GetDistributionLatestCacheReset ( const Model::GetDistributionLatestCacheResetRequest request = {}) const
virtual

Returns the timestamp and status of the last cache reset of a specific Amazon Lightsail content delivery network (CDN) distribution.

See Also:

AWS API Reference

◆ GetDistributionLatestCacheResetAsync()

template<typename GetDistributionLatestCacheResetRequestT = Model::GetDistributionLatestCacheResetRequest>
void Aws::Lightsail::LightsailClient::GetDistributionLatestCacheResetAsync ( const GetDistributionLatestCacheResetResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetDistributionLatestCacheResetRequestT &  request = {} 
) const
inline

An Async wrapper for GetDistributionLatestCacheReset that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2757 of file LightsailClient.h.

◆ GetDistributionLatestCacheResetCallable()

template<typename GetDistributionLatestCacheResetRequestT = Model::GetDistributionLatestCacheResetRequest>
Model::GetDistributionLatestCacheResetOutcomeCallable Aws::Lightsail::LightsailClient::GetDistributionLatestCacheResetCallable ( const GetDistributionLatestCacheResetRequestT &  request = {}) const
inline

A Callable wrapper for GetDistributionLatestCacheReset that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2748 of file LightsailClient.h.

◆ GetDistributionMetricData()

virtual Model::GetDistributionMetricDataOutcome Aws::Lightsail::LightsailClient::GetDistributionMetricData ( const Model::GetDistributionMetricDataRequest request) const
virtual

Returns the data points of a specific metric for an Amazon Lightsail content delivery network (CDN) distribution.

Metrics report the utilization of your resources, and the error counts generated by them. Monitor and collect metric data regularly to maintain the reliability, availability, and performance of your resources.

See Also:

AWS API Reference

◆ GetDistributionMetricDataAsync()

template<typename GetDistributionMetricDataRequestT = Model::GetDistributionMetricDataRequest>
void Aws::Lightsail::LightsailClient::GetDistributionMetricDataAsync ( const GetDistributionMetricDataRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetDistributionMetricData that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2786 of file LightsailClient.h.

◆ GetDistributionMetricDataCallable()

template<typename GetDistributionMetricDataRequestT = Model::GetDistributionMetricDataRequest>
Model::GetDistributionMetricDataOutcomeCallable Aws::Lightsail::LightsailClient::GetDistributionMetricDataCallable ( const GetDistributionMetricDataRequestT &  request) const
inline

A Callable wrapper for GetDistributionMetricData that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2777 of file LightsailClient.h.

◆ GetDistributions()

virtual Model::GetDistributionsOutcome Aws::Lightsail::LightsailClient::GetDistributions ( const Model::GetDistributionsRequest request = {}) const
virtual

Returns information about one or more of your Amazon Lightsail content delivery network (CDN) distributions.

See Also:

AWS API Reference

◆ GetDistributionsAsync()

template<typename GetDistributionsRequestT = Model::GetDistributionsRequest>
void Aws::Lightsail::LightsailClient::GetDistributionsAsync ( const GetDistributionsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetDistributionsRequestT &  request = {} 
) const
inline

An Async wrapper for GetDistributions that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2812 of file LightsailClient.h.

◆ GetDistributionsCallable()

template<typename GetDistributionsRequestT = Model::GetDistributionsRequest>
Model::GetDistributionsOutcomeCallable Aws::Lightsail::LightsailClient::GetDistributionsCallable ( const GetDistributionsRequestT &  request = {}) const
inline

A Callable wrapper for GetDistributions that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2803 of file LightsailClient.h.

◆ GetDomain()

virtual Model::GetDomainOutcome Aws::Lightsail::LightsailClient::GetDomain ( const Model::GetDomainRequest request) const
virtual

Returns information about a specific domain recordset.

See Also:

AWS API Reference

◆ GetDomainAsync()

template<typename GetDomainRequestT = Model::GetDomainRequest>
void Aws::Lightsail::LightsailClient::GetDomainAsync ( const GetDomainRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetDomain that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2838 of file LightsailClient.h.

◆ GetDomainCallable()

template<typename GetDomainRequestT = Model::GetDomainRequest>
Model::GetDomainOutcomeCallable Aws::Lightsail::LightsailClient::GetDomainCallable ( const GetDomainRequestT &  request) const
inline

A Callable wrapper for GetDomain that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2829 of file LightsailClient.h.

◆ GetDomains()

virtual Model::GetDomainsOutcome Aws::Lightsail::LightsailClient::GetDomains ( const Model::GetDomainsRequest request = {}) const
virtual

Returns a list of all domains in the user's account.

See Also:

AWS API Reference

◆ GetDomainsAsync()

template<typename GetDomainsRequestT = Model::GetDomainsRequest>
void Aws::Lightsail::LightsailClient::GetDomainsAsync ( const GetDomainsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetDomainsRequestT &  request = {} 
) const
inline

An Async wrapper for GetDomains that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2864 of file LightsailClient.h.

◆ GetDomainsCallable()

template<typename GetDomainsRequestT = Model::GetDomainsRequest>
Model::GetDomainsOutcomeCallable Aws::Lightsail::LightsailClient::GetDomainsCallable ( const GetDomainsRequestT &  request = {}) const
inline

A Callable wrapper for GetDomains that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2855 of file LightsailClient.h.

◆ GetExportSnapshotRecords()

virtual Model::GetExportSnapshotRecordsOutcome Aws::Lightsail::LightsailClient::GetExportSnapshotRecords ( const Model::GetExportSnapshotRecordsRequest request = {}) const
virtual

Returns all export snapshot records created as a result of the export snapshot operation.

An export snapshot record can be used to create a new Amazon EC2 instance and its related resources with the CreateCloudFormationStack action.

See Also:

AWS API Reference

◆ GetExportSnapshotRecordsAsync()

template<typename GetExportSnapshotRecordsRequestT = Model::GetExportSnapshotRecordsRequest>
void Aws::Lightsail::LightsailClient::GetExportSnapshotRecordsAsync ( const GetExportSnapshotRecordsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetExportSnapshotRecordsRequestT &  request = {} 
) const
inline

An Async wrapper for GetExportSnapshotRecords that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2893 of file LightsailClient.h.

◆ GetExportSnapshotRecordsCallable()

template<typename GetExportSnapshotRecordsRequestT = Model::GetExportSnapshotRecordsRequest>
Model::GetExportSnapshotRecordsOutcomeCallable Aws::Lightsail::LightsailClient::GetExportSnapshotRecordsCallable ( const GetExportSnapshotRecordsRequestT &  request = {}) const
inline

A Callable wrapper for GetExportSnapshotRecords that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2884 of file LightsailClient.h.

◆ GetInstance()

virtual Model::GetInstanceOutcome Aws::Lightsail::LightsailClient::GetInstance ( const Model::GetInstanceRequest request) const
virtual

Returns information about a specific Amazon Lightsail instance, which is a virtual private server.

See Also:

AWS API Reference

◆ GetInstanceAccessDetails()

virtual Model::GetInstanceAccessDetailsOutcome Aws::Lightsail::LightsailClient::GetInstanceAccessDetails ( const Model::GetInstanceAccessDetailsRequest request) const
virtual

Returns temporary SSH keys you can use to connect to a specific virtual private server, or instance.

The get instance access details operation supports tag-based access control via resource tags applied to the resource identified by instance name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ GetInstanceAccessDetailsAsync()

template<typename GetInstanceAccessDetailsRequestT = Model::GetInstanceAccessDetailsRequest>
void Aws::Lightsail::LightsailClient::GetInstanceAccessDetailsAsync ( const GetInstanceAccessDetailsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetInstanceAccessDetails that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2950 of file LightsailClient.h.

◆ GetInstanceAccessDetailsCallable()

template<typename GetInstanceAccessDetailsRequestT = Model::GetInstanceAccessDetailsRequest>
Model::GetInstanceAccessDetailsOutcomeCallable Aws::Lightsail::LightsailClient::GetInstanceAccessDetailsCallable ( const GetInstanceAccessDetailsRequestT &  request) const
inline

A Callable wrapper for GetInstanceAccessDetails that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2941 of file LightsailClient.h.

◆ GetInstanceAsync()

template<typename GetInstanceRequestT = Model::GetInstanceRequest>
void Aws::Lightsail::LightsailClient::GetInstanceAsync ( const GetInstanceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetInstance that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2919 of file LightsailClient.h.

◆ GetInstanceCallable()

template<typename GetInstanceRequestT = Model::GetInstanceRequest>
Model::GetInstanceOutcomeCallable Aws::Lightsail::LightsailClient::GetInstanceCallable ( const GetInstanceRequestT &  request) const
inline

A Callable wrapper for GetInstance that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2910 of file LightsailClient.h.

◆ GetInstanceMetricData()

virtual Model::GetInstanceMetricDataOutcome Aws::Lightsail::LightsailClient::GetInstanceMetricData ( const Model::GetInstanceMetricDataRequest request) const
virtual

Returns the data points for the specified Amazon Lightsail instance metric, given an instance name.

Metrics report the utilization of your resources, and the error counts generated by them. Monitor and collect metric data regularly to maintain the reliability, availability, and performance of your resources.

See Also:

AWS API Reference

◆ GetInstanceMetricDataAsync()

template<typename GetInstanceMetricDataRequestT = Model::GetInstanceMetricDataRequest>
void Aws::Lightsail::LightsailClient::GetInstanceMetricDataAsync ( const GetInstanceMetricDataRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetInstanceMetricData that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2979 of file LightsailClient.h.

◆ GetInstanceMetricDataCallable()

template<typename GetInstanceMetricDataRequestT = Model::GetInstanceMetricDataRequest>
Model::GetInstanceMetricDataOutcomeCallable Aws::Lightsail::LightsailClient::GetInstanceMetricDataCallable ( const GetInstanceMetricDataRequestT &  request) const
inline

A Callable wrapper for GetInstanceMetricData that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2970 of file LightsailClient.h.

◆ GetInstancePortStates()

virtual Model::GetInstancePortStatesOutcome Aws::Lightsail::LightsailClient::GetInstancePortStates ( const Model::GetInstancePortStatesRequest request) const
virtual

Returns the firewall port states for a specific Amazon Lightsail instance, the IP addresses allowed to connect to the instance through the ports, and the protocol.

See Also:

AWS API Reference

◆ GetInstancePortStatesAsync()

template<typename GetInstancePortStatesRequestT = Model::GetInstancePortStatesRequest>
void Aws::Lightsail::LightsailClient::GetInstancePortStatesAsync ( const GetInstancePortStatesRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetInstancePortStates that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3006 of file LightsailClient.h.

◆ GetInstancePortStatesCallable()

template<typename GetInstancePortStatesRequestT = Model::GetInstancePortStatesRequest>
Model::GetInstancePortStatesOutcomeCallable Aws::Lightsail::LightsailClient::GetInstancePortStatesCallable ( const GetInstancePortStatesRequestT &  request) const
inline

A Callable wrapper for GetInstancePortStates that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2997 of file LightsailClient.h.

◆ GetInstances()

virtual Model::GetInstancesOutcome Aws::Lightsail::LightsailClient::GetInstances ( const Model::GetInstancesRequest request = {}) const
virtual

Returns information about all Amazon Lightsail virtual private servers, or instances.

See Also:

AWS API Reference

◆ GetInstancesAsync()

template<typename GetInstancesRequestT = Model::GetInstancesRequest>
void Aws::Lightsail::LightsailClient::GetInstancesAsync ( const GetInstancesResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetInstancesRequestT &  request = {} 
) const
inline

An Async wrapper for GetInstances that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3110 of file LightsailClient.h.

◆ GetInstancesCallable()

template<typename GetInstancesRequestT = Model::GetInstancesRequest>
Model::GetInstancesOutcomeCallable Aws::Lightsail::LightsailClient::GetInstancesCallable ( const GetInstancesRequestT &  request = {}) const
inline

A Callable wrapper for GetInstances that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3101 of file LightsailClient.h.

◆ GetInstanceSnapshot()

virtual Model::GetInstanceSnapshotOutcome Aws::Lightsail::LightsailClient::GetInstanceSnapshot ( const Model::GetInstanceSnapshotRequest request) const
virtual

Returns information about a specific instance snapshot.

See Also:

AWS API Reference

◆ GetInstanceSnapshotAsync()

template<typename GetInstanceSnapshotRequestT = Model::GetInstanceSnapshotRequest>
void Aws::Lightsail::LightsailClient::GetInstanceSnapshotAsync ( const GetInstanceSnapshotRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetInstanceSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3032 of file LightsailClient.h.

◆ GetInstanceSnapshotCallable()

template<typename GetInstanceSnapshotRequestT = Model::GetInstanceSnapshotRequest>
Model::GetInstanceSnapshotOutcomeCallable Aws::Lightsail::LightsailClient::GetInstanceSnapshotCallable ( const GetInstanceSnapshotRequestT &  request) const
inline

A Callable wrapper for GetInstanceSnapshot that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3023 of file LightsailClient.h.

◆ GetInstanceSnapshots()

virtual Model::GetInstanceSnapshotsOutcome Aws::Lightsail::LightsailClient::GetInstanceSnapshots ( const Model::GetInstanceSnapshotsRequest request = {}) const
virtual

Returns all instance snapshots for the user's account.

See Also:

AWS API Reference

◆ GetInstanceSnapshotsAsync()

template<typename GetInstanceSnapshotsRequestT = Model::GetInstanceSnapshotsRequest>
void Aws::Lightsail::LightsailClient::GetInstanceSnapshotsAsync ( const GetInstanceSnapshotsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetInstanceSnapshotsRequestT &  request = {} 
) const
inline

An Async wrapper for GetInstanceSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3058 of file LightsailClient.h.

◆ GetInstanceSnapshotsCallable()

template<typename GetInstanceSnapshotsRequestT = Model::GetInstanceSnapshotsRequest>
Model::GetInstanceSnapshotsOutcomeCallable Aws::Lightsail::LightsailClient::GetInstanceSnapshotsCallable ( const GetInstanceSnapshotsRequestT &  request = {}) const
inline

A Callable wrapper for GetInstanceSnapshots that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3049 of file LightsailClient.h.

◆ GetInstanceState()

virtual Model::GetInstanceStateOutcome Aws::Lightsail::LightsailClient::GetInstanceState ( const Model::GetInstanceStateRequest request) const
virtual

Returns the state of a specific instance. Works on one instance at a time.

See Also:

AWS API Reference

◆ GetInstanceStateAsync()

template<typename GetInstanceStateRequestT = Model::GetInstanceStateRequest>
void Aws::Lightsail::LightsailClient::GetInstanceStateAsync ( const GetInstanceStateRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetInstanceState that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3084 of file LightsailClient.h.

◆ GetInstanceStateCallable()

template<typename GetInstanceStateRequestT = Model::GetInstanceStateRequest>
Model::GetInstanceStateOutcomeCallable Aws::Lightsail::LightsailClient::GetInstanceStateCallable ( const GetInstanceStateRequestT &  request) const
inline

A Callable wrapper for GetInstanceState that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3075 of file LightsailClient.h.

◆ GetKeyPair()

virtual Model::GetKeyPairOutcome Aws::Lightsail::LightsailClient::GetKeyPair ( const Model::GetKeyPairRequest request) const
virtual

Returns information about a specific key pair.

See Also:

AWS API Reference

◆ GetKeyPairAsync()

template<typename GetKeyPairRequestT = Model::GetKeyPairRequest>
void Aws::Lightsail::LightsailClient::GetKeyPairAsync ( const GetKeyPairRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetKeyPair that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3135 of file LightsailClient.h.

◆ GetKeyPairCallable()

template<typename GetKeyPairRequestT = Model::GetKeyPairRequest>
Model::GetKeyPairOutcomeCallable Aws::Lightsail::LightsailClient::GetKeyPairCallable ( const GetKeyPairRequestT &  request) const
inline

A Callable wrapper for GetKeyPair that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3126 of file LightsailClient.h.

◆ GetKeyPairs()

virtual Model::GetKeyPairsOutcome Aws::Lightsail::LightsailClient::GetKeyPairs ( const Model::GetKeyPairsRequest request = {}) const
virtual

Returns information about all key pairs in the user's account.

See Also:

AWS API Reference

◆ GetKeyPairsAsync()

template<typename GetKeyPairsRequestT = Model::GetKeyPairsRequest>
void Aws::Lightsail::LightsailClient::GetKeyPairsAsync ( const GetKeyPairsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetKeyPairsRequestT &  request = {} 
) const
inline

An Async wrapper for GetKeyPairs that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3161 of file LightsailClient.h.

◆ GetKeyPairsCallable()

template<typename GetKeyPairsRequestT = Model::GetKeyPairsRequest>
Model::GetKeyPairsOutcomeCallable Aws::Lightsail::LightsailClient::GetKeyPairsCallable ( const GetKeyPairsRequestT &  request = {}) const
inline

A Callable wrapper for GetKeyPairs that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3152 of file LightsailClient.h.

◆ GetLoadBalancer()

virtual Model::GetLoadBalancerOutcome Aws::Lightsail::LightsailClient::GetLoadBalancer ( const Model::GetLoadBalancerRequest request) const
virtual

Returns information about the specified Lightsail load balancer.

See Also:

AWS API Reference

◆ GetLoadBalancerAsync()

template<typename GetLoadBalancerRequestT = Model::GetLoadBalancerRequest>
void Aws::Lightsail::LightsailClient::GetLoadBalancerAsync ( const GetLoadBalancerRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetLoadBalancer that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3187 of file LightsailClient.h.

◆ GetLoadBalancerCallable()

template<typename GetLoadBalancerRequestT = Model::GetLoadBalancerRequest>
Model::GetLoadBalancerOutcomeCallable Aws::Lightsail::LightsailClient::GetLoadBalancerCallable ( const GetLoadBalancerRequestT &  request) const
inline

A Callable wrapper for GetLoadBalancer that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3178 of file LightsailClient.h.

◆ GetLoadBalancerMetricData()

virtual Model::GetLoadBalancerMetricDataOutcome Aws::Lightsail::LightsailClient::GetLoadBalancerMetricData ( const Model::GetLoadBalancerMetricDataRequest request) const
virtual

Returns information about health metrics for your Lightsail load balancer.

Metrics report the utilization of your resources, and the error counts generated by them. Monitor and collect metric data regularly to maintain the reliability, availability, and performance of your resources.

See Also:

AWS API Reference

◆ GetLoadBalancerMetricDataAsync()

template<typename GetLoadBalancerMetricDataRequestT = Model::GetLoadBalancerMetricDataRequest>
void Aws::Lightsail::LightsailClient::GetLoadBalancerMetricDataAsync ( const GetLoadBalancerMetricDataRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetLoadBalancerMetricData that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3216 of file LightsailClient.h.

◆ GetLoadBalancerMetricDataCallable()

template<typename GetLoadBalancerMetricDataRequestT = Model::GetLoadBalancerMetricDataRequest>
Model::GetLoadBalancerMetricDataOutcomeCallable Aws::Lightsail::LightsailClient::GetLoadBalancerMetricDataCallable ( const GetLoadBalancerMetricDataRequestT &  request) const
inline

A Callable wrapper for GetLoadBalancerMetricData that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3207 of file LightsailClient.h.

◆ GetLoadBalancers()

virtual Model::GetLoadBalancersOutcome Aws::Lightsail::LightsailClient::GetLoadBalancers ( const Model::GetLoadBalancersRequest request = {}) const
virtual

Returns information about all load balancers in an account.

See Also:

AWS API Reference

◆ GetLoadBalancersAsync()

template<typename GetLoadBalancersRequestT = Model::GetLoadBalancersRequest>
void Aws::Lightsail::LightsailClient::GetLoadBalancersAsync ( const GetLoadBalancersResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetLoadBalancersRequestT &  request = {} 
) const
inline

An Async wrapper for GetLoadBalancers that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3301 of file LightsailClient.h.

◆ GetLoadBalancersCallable()

template<typename GetLoadBalancersRequestT = Model::GetLoadBalancersRequest>
Model::GetLoadBalancersOutcomeCallable Aws::Lightsail::LightsailClient::GetLoadBalancersCallable ( const GetLoadBalancersRequestT &  request = {}) const
inline

A Callable wrapper for GetLoadBalancers that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3292 of file LightsailClient.h.

◆ GetLoadBalancerTlsCertificates()

virtual Model::GetLoadBalancerTlsCertificatesOutcome Aws::Lightsail::LightsailClient::GetLoadBalancerTlsCertificates ( const Model::GetLoadBalancerTlsCertificatesRequest request) const
virtual

Returns information about the TLS certificates that are associated with the specified Lightsail load balancer.

TLS is just an updated, more secure version of Secure Socket Layer (SSL).

You can have a maximum of 2 certificates associated with a Lightsail load balancer. One is active and the other is inactive.

See Also:

AWS API Reference

◆ GetLoadBalancerTlsCertificatesAsync()

template<typename GetLoadBalancerTlsCertificatesRequestT = Model::GetLoadBalancerTlsCertificatesRequest>
void Aws::Lightsail::LightsailClient::GetLoadBalancerTlsCertificatesAsync ( const GetLoadBalancerTlsCertificatesRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetLoadBalancerTlsCertificates that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3245 of file LightsailClient.h.

◆ GetLoadBalancerTlsCertificatesCallable()

template<typename GetLoadBalancerTlsCertificatesRequestT = Model::GetLoadBalancerTlsCertificatesRequest>
Model::GetLoadBalancerTlsCertificatesOutcomeCallable Aws::Lightsail::LightsailClient::GetLoadBalancerTlsCertificatesCallable ( const GetLoadBalancerTlsCertificatesRequestT &  request) const
inline

A Callable wrapper for GetLoadBalancerTlsCertificates that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3236 of file LightsailClient.h.

◆ GetLoadBalancerTlsPolicies()

virtual Model::GetLoadBalancerTlsPoliciesOutcome Aws::Lightsail::LightsailClient::GetLoadBalancerTlsPolicies ( const Model::GetLoadBalancerTlsPoliciesRequest request = {}) const
virtual

Returns a list of TLS security policies that you can apply to Lightsail load balancers.

For more information about load balancer TLS security policies, see Configuring TLS security policies on your Amazon Lightsail load balancers in the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ GetLoadBalancerTlsPoliciesAsync()

template<typename GetLoadBalancerTlsPoliciesRequestT = Model::GetLoadBalancerTlsPoliciesRequest>
void Aws::Lightsail::LightsailClient::GetLoadBalancerTlsPoliciesAsync ( const GetLoadBalancerTlsPoliciesResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetLoadBalancerTlsPoliciesRequestT &  request = {} 
) const
inline

An Async wrapper for GetLoadBalancerTlsPolicies that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3275 of file LightsailClient.h.

◆ GetLoadBalancerTlsPoliciesCallable()

template<typename GetLoadBalancerTlsPoliciesRequestT = Model::GetLoadBalancerTlsPoliciesRequest>
Model::GetLoadBalancerTlsPoliciesOutcomeCallable Aws::Lightsail::LightsailClient::GetLoadBalancerTlsPoliciesCallable ( const GetLoadBalancerTlsPoliciesRequestT &  request = {}) const
inline

A Callable wrapper for GetLoadBalancerTlsPolicies that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3266 of file LightsailClient.h.

◆ GetOperation()

virtual Model::GetOperationOutcome Aws::Lightsail::LightsailClient::GetOperation ( const Model::GetOperationRequest request) const
virtual

Returns information about a specific operation. Operations include events such as when you create an instance, allocate a static IP, attach a static IP, and so on.

See Also:

AWS API Reference

◆ GetOperationAsync()

template<typename GetOperationRequestT = Model::GetOperationRequest>
void Aws::Lightsail::LightsailClient::GetOperationAsync ( const GetOperationRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetOperation that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3328 of file LightsailClient.h.

◆ GetOperationCallable()

template<typename GetOperationRequestT = Model::GetOperationRequest>
Model::GetOperationOutcomeCallable Aws::Lightsail::LightsailClient::GetOperationCallable ( const GetOperationRequestT &  request) const
inline

A Callable wrapper for GetOperation that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3319 of file LightsailClient.h.

◆ GetOperations()

virtual Model::GetOperationsOutcome Aws::Lightsail::LightsailClient::GetOperations ( const Model::GetOperationsRequest request = {}) const
virtual

Returns information about all operations.

Results are returned from oldest to newest, up to a maximum of 200. Results can be paged by making each subsequent call to GetOperations use the maximum (last) statusChangedAt value from the previous request.

See Also:

AWS API Reference

◆ GetOperationsAsync()

template<typename GetOperationsRequestT = Model::GetOperationsRequest>
void Aws::Lightsail::LightsailClient::GetOperationsAsync ( const GetOperationsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetOperationsRequestT &  request = {} 
) const
inline

An Async wrapper for GetOperations that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3357 of file LightsailClient.h.

◆ GetOperationsCallable()

template<typename GetOperationsRequestT = Model::GetOperationsRequest>
Model::GetOperationsOutcomeCallable Aws::Lightsail::LightsailClient::GetOperationsCallable ( const GetOperationsRequestT &  request = {}) const
inline

A Callable wrapper for GetOperations that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3348 of file LightsailClient.h.

◆ GetOperationsForResource()

virtual Model::GetOperationsForResourceOutcome Aws::Lightsail::LightsailClient::GetOperationsForResource ( const Model::GetOperationsForResourceRequest request) const
virtual

Gets operations for a specific resource (an instance or a static IP).

See Also:

AWS API Reference

◆ GetOperationsForResourceAsync()

template<typename GetOperationsForResourceRequestT = Model::GetOperationsForResourceRequest>
void Aws::Lightsail::LightsailClient::GetOperationsForResourceAsync ( const GetOperationsForResourceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetOperationsForResource that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3383 of file LightsailClient.h.

◆ GetOperationsForResourceCallable()

template<typename GetOperationsForResourceRequestT = Model::GetOperationsForResourceRequest>
Model::GetOperationsForResourceOutcomeCallable Aws::Lightsail::LightsailClient::GetOperationsForResourceCallable ( const GetOperationsForResourceRequestT &  request) const
inline

A Callable wrapper for GetOperationsForResource that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3374 of file LightsailClient.h.

◆ GetRegions()

virtual Model::GetRegionsOutcome Aws::Lightsail::LightsailClient::GetRegions ( const Model::GetRegionsRequest request = {}) const
virtual

Returns a list of all valid regions for Amazon Lightsail. Use the include availability zones parameter to also return the Availability Zones in a region.

See Also:

AWS API Reference

◆ GetRegionsAsync()

template<typename GetRegionsRequestT = Model::GetRegionsRequest>
void Aws::Lightsail::LightsailClient::GetRegionsAsync ( const GetRegionsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetRegionsRequestT &  request = {} 
) const
inline

An Async wrapper for GetRegions that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3410 of file LightsailClient.h.

◆ GetRegionsCallable()

template<typename GetRegionsRequestT = Model::GetRegionsRequest>
Model::GetRegionsOutcomeCallable Aws::Lightsail::LightsailClient::GetRegionsCallable ( const GetRegionsRequestT &  request = {}) const
inline

A Callable wrapper for GetRegions that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3401 of file LightsailClient.h.

◆ GetRelationalDatabase()

virtual Model::GetRelationalDatabaseOutcome Aws::Lightsail::LightsailClient::GetRelationalDatabase ( const Model::GetRelationalDatabaseRequest request) const
virtual

Returns information about a specific database in Amazon Lightsail.

See Also:

AWS API Reference

◆ GetRelationalDatabaseAsync()

template<typename GetRelationalDatabaseRequestT = Model::GetRelationalDatabaseRequest>
void Aws::Lightsail::LightsailClient::GetRelationalDatabaseAsync ( const GetRelationalDatabaseRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetRelationalDatabase that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3436 of file LightsailClient.h.

◆ GetRelationalDatabaseBlueprints()

virtual Model::GetRelationalDatabaseBlueprintsOutcome Aws::Lightsail::LightsailClient::GetRelationalDatabaseBlueprints ( const Model::GetRelationalDatabaseBlueprintsRequest request = {}) const
virtual

Returns a list of available database blueprints in Amazon Lightsail. A blueprint describes the major engine version of a database.

You can use a blueprint ID to create a new database that runs a specific database engine.

See Also:

AWS API Reference

◆ GetRelationalDatabaseBlueprintsAsync()

template<typename GetRelationalDatabaseBlueprintsRequestT = Model::GetRelationalDatabaseBlueprintsRequest>
void Aws::Lightsail::LightsailClient::GetRelationalDatabaseBlueprintsAsync ( const GetRelationalDatabaseBlueprintsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetRelationalDatabaseBlueprintsRequestT &  request = {} 
) const
inline

An Async wrapper for GetRelationalDatabaseBlueprints that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3464 of file LightsailClient.h.

◆ GetRelationalDatabaseBlueprintsCallable()

template<typename GetRelationalDatabaseBlueprintsRequestT = Model::GetRelationalDatabaseBlueprintsRequest>
Model::GetRelationalDatabaseBlueprintsOutcomeCallable Aws::Lightsail::LightsailClient::GetRelationalDatabaseBlueprintsCallable ( const GetRelationalDatabaseBlueprintsRequestT &  request = {}) const
inline

A Callable wrapper for GetRelationalDatabaseBlueprints that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3455 of file LightsailClient.h.

◆ GetRelationalDatabaseBundles()

virtual Model::GetRelationalDatabaseBundlesOutcome Aws::Lightsail::LightsailClient::GetRelationalDatabaseBundles ( const Model::GetRelationalDatabaseBundlesRequest request = {}) const
virtual

Returns the list of bundles that are available in Amazon Lightsail. A bundle describes the performance specifications for a database.

You can use a bundle ID to create a new database with explicit performance specifications.

See Also:

AWS API Reference

◆ GetRelationalDatabaseBundlesAsync()

template<typename GetRelationalDatabaseBundlesRequestT = Model::GetRelationalDatabaseBundlesRequest>
void Aws::Lightsail::LightsailClient::GetRelationalDatabaseBundlesAsync ( const GetRelationalDatabaseBundlesResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetRelationalDatabaseBundlesRequestT &  request = {} 
) const
inline

An Async wrapper for GetRelationalDatabaseBundles that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3492 of file LightsailClient.h.

◆ GetRelationalDatabaseBundlesCallable()

template<typename GetRelationalDatabaseBundlesRequestT = Model::GetRelationalDatabaseBundlesRequest>
Model::GetRelationalDatabaseBundlesOutcomeCallable Aws::Lightsail::LightsailClient::GetRelationalDatabaseBundlesCallable ( const GetRelationalDatabaseBundlesRequestT &  request = {}) const
inline

A Callable wrapper for GetRelationalDatabaseBundles that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3483 of file LightsailClient.h.

◆ GetRelationalDatabaseCallable()

template<typename GetRelationalDatabaseRequestT = Model::GetRelationalDatabaseRequest>
Model::GetRelationalDatabaseOutcomeCallable Aws::Lightsail::LightsailClient::GetRelationalDatabaseCallable ( const GetRelationalDatabaseRequestT &  request) const
inline

A Callable wrapper for GetRelationalDatabase that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3427 of file LightsailClient.h.

◆ GetRelationalDatabaseEvents()

virtual Model::GetRelationalDatabaseEventsOutcome Aws::Lightsail::LightsailClient::GetRelationalDatabaseEvents ( const Model::GetRelationalDatabaseEventsRequest request) const
virtual

Returns a list of events for a specific database in Amazon Lightsail.

See Also:

AWS API Reference

◆ GetRelationalDatabaseEventsAsync()

template<typename GetRelationalDatabaseEventsRequestT = Model::GetRelationalDatabaseEventsRequest>
void Aws::Lightsail::LightsailClient::GetRelationalDatabaseEventsAsync ( const GetRelationalDatabaseEventsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetRelationalDatabaseEvents that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3518 of file LightsailClient.h.

◆ GetRelationalDatabaseEventsCallable()

template<typename GetRelationalDatabaseEventsRequestT = Model::GetRelationalDatabaseEventsRequest>
Model::GetRelationalDatabaseEventsOutcomeCallable Aws::Lightsail::LightsailClient::GetRelationalDatabaseEventsCallable ( const GetRelationalDatabaseEventsRequestT &  request) const
inline

A Callable wrapper for GetRelationalDatabaseEvents that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3509 of file LightsailClient.h.

◆ GetRelationalDatabaseLogEvents()

virtual Model::GetRelationalDatabaseLogEventsOutcome Aws::Lightsail::LightsailClient::GetRelationalDatabaseLogEvents ( const Model::GetRelationalDatabaseLogEventsRequest request) const
virtual

Returns a list of log events for a database in Amazon Lightsail.

See Also:

AWS API Reference

◆ GetRelationalDatabaseLogEventsAsync()

template<typename GetRelationalDatabaseLogEventsRequestT = Model::GetRelationalDatabaseLogEventsRequest>
void Aws::Lightsail::LightsailClient::GetRelationalDatabaseLogEventsAsync ( const GetRelationalDatabaseLogEventsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetRelationalDatabaseLogEvents that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3544 of file LightsailClient.h.

◆ GetRelationalDatabaseLogEventsCallable()

template<typename GetRelationalDatabaseLogEventsRequestT = Model::GetRelationalDatabaseLogEventsRequest>
Model::GetRelationalDatabaseLogEventsOutcomeCallable Aws::Lightsail::LightsailClient::GetRelationalDatabaseLogEventsCallable ( const GetRelationalDatabaseLogEventsRequestT &  request) const
inline

A Callable wrapper for GetRelationalDatabaseLogEvents that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3535 of file LightsailClient.h.

◆ GetRelationalDatabaseLogStreams()

virtual Model::GetRelationalDatabaseLogStreamsOutcome Aws::Lightsail::LightsailClient::GetRelationalDatabaseLogStreams ( const Model::GetRelationalDatabaseLogStreamsRequest request) const
virtual

Returns a list of available log streams for a specific database in Amazon Lightsail.

See Also:

AWS API Reference

◆ GetRelationalDatabaseLogStreamsAsync()

template<typename GetRelationalDatabaseLogStreamsRequestT = Model::GetRelationalDatabaseLogStreamsRequest>
void Aws::Lightsail::LightsailClient::GetRelationalDatabaseLogStreamsAsync ( const GetRelationalDatabaseLogStreamsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetRelationalDatabaseLogStreams that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3570 of file LightsailClient.h.

◆ GetRelationalDatabaseLogStreamsCallable()

template<typename GetRelationalDatabaseLogStreamsRequestT = Model::GetRelationalDatabaseLogStreamsRequest>
Model::GetRelationalDatabaseLogStreamsOutcomeCallable Aws::Lightsail::LightsailClient::GetRelationalDatabaseLogStreamsCallable ( const GetRelationalDatabaseLogStreamsRequestT &  request) const
inline

A Callable wrapper for GetRelationalDatabaseLogStreams that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3561 of file LightsailClient.h.

◆ GetRelationalDatabaseMasterUserPassword()

virtual Model::GetRelationalDatabaseMasterUserPasswordOutcome Aws::Lightsail::LightsailClient::GetRelationalDatabaseMasterUserPassword ( const Model::GetRelationalDatabaseMasterUserPasswordRequest request) const
virtual

Returns the current, previous, or pending versions of the master user password for a Lightsail database.

The GetRelationalDatabaseMasterUserPassword operation supports tag-based access control via resource tags applied to the resource identified by relationalDatabaseName.

See Also:

AWS API Reference

◆ GetRelationalDatabaseMasterUserPasswordAsync()

template<typename GetRelationalDatabaseMasterUserPasswordRequestT = Model::GetRelationalDatabaseMasterUserPasswordRequest>
void Aws::Lightsail::LightsailClient::GetRelationalDatabaseMasterUserPasswordAsync ( const GetRelationalDatabaseMasterUserPasswordRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetRelationalDatabaseMasterUserPassword that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3599 of file LightsailClient.h.

◆ GetRelationalDatabaseMasterUserPasswordCallable()

template<typename GetRelationalDatabaseMasterUserPasswordRequestT = Model::GetRelationalDatabaseMasterUserPasswordRequest>
Model::GetRelationalDatabaseMasterUserPasswordOutcomeCallable Aws::Lightsail::LightsailClient::GetRelationalDatabaseMasterUserPasswordCallable ( const GetRelationalDatabaseMasterUserPasswordRequestT &  request) const
inline

A Callable wrapper for GetRelationalDatabaseMasterUserPassword that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3590 of file LightsailClient.h.

◆ GetRelationalDatabaseMetricData()

virtual Model::GetRelationalDatabaseMetricDataOutcome Aws::Lightsail::LightsailClient::GetRelationalDatabaseMetricData ( const Model::GetRelationalDatabaseMetricDataRequest request) const
virtual

Returns the data points of the specified metric for a database in Amazon Lightsail.

Metrics report the utilization of your resources, and the error counts generated by them. Monitor and collect metric data regularly to maintain the reliability, availability, and performance of your resources.

See Also:

AWS API Reference

◆ GetRelationalDatabaseMetricDataAsync()

template<typename GetRelationalDatabaseMetricDataRequestT = Model::GetRelationalDatabaseMetricDataRequest>
void Aws::Lightsail::LightsailClient::GetRelationalDatabaseMetricDataAsync ( const GetRelationalDatabaseMetricDataRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetRelationalDatabaseMetricData that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3628 of file LightsailClient.h.

◆ GetRelationalDatabaseMetricDataCallable()

template<typename GetRelationalDatabaseMetricDataRequestT = Model::GetRelationalDatabaseMetricDataRequest>
Model::GetRelationalDatabaseMetricDataOutcomeCallable Aws::Lightsail::LightsailClient::GetRelationalDatabaseMetricDataCallable ( const GetRelationalDatabaseMetricDataRequestT &  request) const
inline

A Callable wrapper for GetRelationalDatabaseMetricData that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3619 of file LightsailClient.h.

◆ GetRelationalDatabaseParameters()

virtual Model::GetRelationalDatabaseParametersOutcome Aws::Lightsail::LightsailClient::GetRelationalDatabaseParameters ( const Model::GetRelationalDatabaseParametersRequest request) const
virtual

Returns all of the runtime parameters offered by the underlying database software, or engine, for a specific database in Amazon Lightsail.

In addition to the parameter names and values, this operation returns other information about each parameter. This information includes whether changes require a reboot, whether the parameter is modifiable, the allowed values, and the data types.

See Also:

AWS API Reference

◆ GetRelationalDatabaseParametersAsync()

template<typename GetRelationalDatabaseParametersRequestT = Model::GetRelationalDatabaseParametersRequest>
void Aws::Lightsail::LightsailClient::GetRelationalDatabaseParametersAsync ( const GetRelationalDatabaseParametersRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetRelationalDatabaseParameters that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3658 of file LightsailClient.h.

◆ GetRelationalDatabaseParametersCallable()

template<typename GetRelationalDatabaseParametersRequestT = Model::GetRelationalDatabaseParametersRequest>
Model::GetRelationalDatabaseParametersOutcomeCallable Aws::Lightsail::LightsailClient::GetRelationalDatabaseParametersCallable ( const GetRelationalDatabaseParametersRequestT &  request) const
inline

A Callable wrapper for GetRelationalDatabaseParameters that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3649 of file LightsailClient.h.

◆ GetRelationalDatabases()

virtual Model::GetRelationalDatabasesOutcome Aws::Lightsail::LightsailClient::GetRelationalDatabases ( const Model::GetRelationalDatabasesRequest request = {}) const
virtual

Returns information about all of your databases in Amazon Lightsail.

See Also:

AWS API Reference

◆ GetRelationalDatabasesAsync()

template<typename GetRelationalDatabasesRequestT = Model::GetRelationalDatabasesRequest>
void Aws::Lightsail::LightsailClient::GetRelationalDatabasesAsync ( const GetRelationalDatabasesResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetRelationalDatabasesRequestT &  request = {} 
) const
inline

An Async wrapper for GetRelationalDatabases that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3736 of file LightsailClient.h.

◆ GetRelationalDatabasesCallable()

template<typename GetRelationalDatabasesRequestT = Model::GetRelationalDatabasesRequest>
Model::GetRelationalDatabasesOutcomeCallable Aws::Lightsail::LightsailClient::GetRelationalDatabasesCallable ( const GetRelationalDatabasesRequestT &  request = {}) const
inline

A Callable wrapper for GetRelationalDatabases that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3727 of file LightsailClient.h.

◆ GetRelationalDatabaseSnapshot()

virtual Model::GetRelationalDatabaseSnapshotOutcome Aws::Lightsail::LightsailClient::GetRelationalDatabaseSnapshot ( const Model::GetRelationalDatabaseSnapshotRequest request) const
virtual

Returns information about a specific database snapshot in Amazon Lightsail.

See Also:

AWS API Reference

◆ GetRelationalDatabaseSnapshotAsync()

template<typename GetRelationalDatabaseSnapshotRequestT = Model::GetRelationalDatabaseSnapshotRequest>
void Aws::Lightsail::LightsailClient::GetRelationalDatabaseSnapshotAsync ( const GetRelationalDatabaseSnapshotRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetRelationalDatabaseSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3684 of file LightsailClient.h.

◆ GetRelationalDatabaseSnapshotCallable()

template<typename GetRelationalDatabaseSnapshotRequestT = Model::GetRelationalDatabaseSnapshotRequest>
Model::GetRelationalDatabaseSnapshotOutcomeCallable Aws::Lightsail::LightsailClient::GetRelationalDatabaseSnapshotCallable ( const GetRelationalDatabaseSnapshotRequestT &  request) const
inline

A Callable wrapper for GetRelationalDatabaseSnapshot that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3675 of file LightsailClient.h.

◆ GetRelationalDatabaseSnapshots()

virtual Model::GetRelationalDatabaseSnapshotsOutcome Aws::Lightsail::LightsailClient::GetRelationalDatabaseSnapshots ( const Model::GetRelationalDatabaseSnapshotsRequest request = {}) const
virtual

Returns information about all of your database snapshots in Amazon Lightsail.

See Also:

AWS API Reference

◆ GetRelationalDatabaseSnapshotsAsync()

template<typename GetRelationalDatabaseSnapshotsRequestT = Model::GetRelationalDatabaseSnapshotsRequest>
void Aws::Lightsail::LightsailClient::GetRelationalDatabaseSnapshotsAsync ( const GetRelationalDatabaseSnapshotsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetRelationalDatabaseSnapshotsRequestT &  request = {} 
) const
inline

An Async wrapper for GetRelationalDatabaseSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3710 of file LightsailClient.h.

◆ GetRelationalDatabaseSnapshotsCallable()

template<typename GetRelationalDatabaseSnapshotsRequestT = Model::GetRelationalDatabaseSnapshotsRequest>
Model::GetRelationalDatabaseSnapshotsOutcomeCallable Aws::Lightsail::LightsailClient::GetRelationalDatabaseSnapshotsCallable ( const GetRelationalDatabaseSnapshotsRequestT &  request = {}) const
inline

A Callable wrapper for GetRelationalDatabaseSnapshots that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3701 of file LightsailClient.h.

◆ GetServiceName()

static const char * Aws::Lightsail::LightsailClient::GetServiceName ( )
static

◆ GetSetupHistory()

virtual Model::GetSetupHistoryOutcome Aws::Lightsail::LightsailClient::GetSetupHistory ( const Model::GetSetupHistoryRequest request) const
virtual

Returns detailed information for five of the most recent SetupInstanceHttps requests that were ran on the target instance.

See Also:

AWS API Reference

◆ GetSetupHistoryAsync()

template<typename GetSetupHistoryRequestT = Model::GetSetupHistoryRequest>
void Aws::Lightsail::LightsailClient::GetSetupHistoryAsync ( const GetSetupHistoryRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetSetupHistory that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3763 of file LightsailClient.h.

◆ GetSetupHistoryCallable()

template<typename GetSetupHistoryRequestT = Model::GetSetupHistoryRequest>
Model::GetSetupHistoryOutcomeCallable Aws::Lightsail::LightsailClient::GetSetupHistoryCallable ( const GetSetupHistoryRequestT &  request) const
inline

A Callable wrapper for GetSetupHistory that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3754 of file LightsailClient.h.

◆ GetStaticIp()

virtual Model::GetStaticIpOutcome Aws::Lightsail::LightsailClient::GetStaticIp ( const Model::GetStaticIpRequest request) const
virtual

Returns information about an Amazon Lightsail static IP.

See Also:

AWS API Reference

◆ GetStaticIpAsync()

template<typename GetStaticIpRequestT = Model::GetStaticIpRequest>
void Aws::Lightsail::LightsailClient::GetStaticIpAsync ( const GetStaticIpRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetStaticIp that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3789 of file LightsailClient.h.

◆ GetStaticIpCallable()

template<typename GetStaticIpRequestT = Model::GetStaticIpRequest>
Model::GetStaticIpOutcomeCallable Aws::Lightsail::LightsailClient::GetStaticIpCallable ( const GetStaticIpRequestT &  request) const
inline

A Callable wrapper for GetStaticIp that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3780 of file LightsailClient.h.

◆ GetStaticIps()

virtual Model::GetStaticIpsOutcome Aws::Lightsail::LightsailClient::GetStaticIps ( const Model::GetStaticIpsRequest request = {}) const
virtual

Returns information about all static IPs in the user's account.

See Also:

AWS API Reference

◆ GetStaticIpsAsync()

template<typename GetStaticIpsRequestT = Model::GetStaticIpsRequest>
void Aws::Lightsail::LightsailClient::GetStaticIpsAsync ( const GetStaticIpsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetStaticIpsRequestT &  request = {} 
) const
inline

An Async wrapper for GetStaticIps that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3815 of file LightsailClient.h.

◆ GetStaticIpsCallable()

template<typename GetStaticIpsRequestT = Model::GetStaticIpsRequest>
Model::GetStaticIpsOutcomeCallable Aws::Lightsail::LightsailClient::GetStaticIpsCallable ( const GetStaticIpsRequestT &  request = {}) const
inline

A Callable wrapper for GetStaticIps that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3806 of file LightsailClient.h.

◆ ImportKeyPair()

virtual Model::ImportKeyPairOutcome Aws::Lightsail::LightsailClient::ImportKeyPair ( const Model::ImportKeyPairRequest request) const
virtual

Imports a public SSH key from a specific key pair.

See Also:


AWS API Reference

◆ ImportKeyPairAsync()

template<typename ImportKeyPairRequestT = Model::ImportKeyPairRequest>
void Aws::Lightsail::LightsailClient::ImportKeyPairAsync ( const ImportKeyPairRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ImportKeyPair that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3841 of file LightsailClient.h.

◆ ImportKeyPairCallable()

template<typename ImportKeyPairRequestT = Model::ImportKeyPairRequest>
Model::ImportKeyPairOutcomeCallable Aws::Lightsail::LightsailClient::ImportKeyPairCallable ( const ImportKeyPairRequestT &  request) const
inline

A Callable wrapper for ImportKeyPair that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3832 of file LightsailClient.h.

◆ IsVpcPeered()

virtual Model::IsVpcPeeredOutcome Aws::Lightsail::LightsailClient::IsVpcPeered ( const Model::IsVpcPeeredRequest request = {}) const
virtual

Returns a Boolean value indicating whether your Lightsail VPC is peered.

See Also:

AWS API Reference

◆ IsVpcPeeredAsync()

template<typename IsVpcPeeredRequestT = Model::IsVpcPeeredRequest>
void Aws::Lightsail::LightsailClient::IsVpcPeeredAsync ( const IsVpcPeeredResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const IsVpcPeeredRequestT &  request = {} 
) const
inline

An Async wrapper for IsVpcPeered that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3867 of file LightsailClient.h.

◆ IsVpcPeeredCallable()

template<typename IsVpcPeeredRequestT = Model::IsVpcPeeredRequest>
Model::IsVpcPeeredOutcomeCallable Aws::Lightsail::LightsailClient::IsVpcPeeredCallable ( const IsVpcPeeredRequestT &  request = {}) const
inline

A Callable wrapper for IsVpcPeered that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3858 of file LightsailClient.h.

◆ OpenInstancePublicPorts()

virtual Model::OpenInstancePublicPortsOutcome Aws::Lightsail::LightsailClient::OpenInstancePublicPorts ( const Model::OpenInstancePublicPortsRequest request) const
virtual

Opens ports for a specific Amazon Lightsail instance, and specifies the IP addresses allowed to connect to the instance through the ports, and the protocol.

The OpenInstancePublicPorts action supports tag-based access control via resource tags applied to the resource identified by instanceName. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ OpenInstancePublicPortsAsync()

template<typename OpenInstancePublicPortsRequestT = Model::OpenInstancePublicPortsRequest>
void Aws::Lightsail::LightsailClient::OpenInstancePublicPortsAsync ( const OpenInstancePublicPortsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for OpenInstancePublicPorts that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3898 of file LightsailClient.h.

◆ OpenInstancePublicPortsCallable()

template<typename OpenInstancePublicPortsRequestT = Model::OpenInstancePublicPortsRequest>
Model::OpenInstancePublicPortsOutcomeCallable Aws::Lightsail::LightsailClient::OpenInstancePublicPortsCallable ( const OpenInstancePublicPortsRequestT &  request) const
inline

A Callable wrapper for OpenInstancePublicPorts that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3889 of file LightsailClient.h.

◆ OverrideEndpoint()

void Aws::Lightsail::LightsailClient::OverrideEndpoint ( const Aws::String endpoint)

◆ PeerVpc()

virtual Model::PeerVpcOutcome Aws::Lightsail::LightsailClient::PeerVpc ( const Model::PeerVpcRequest request = {}) const
virtual

Peers the Lightsail VPC with the user's default VPC.

See Also:

AWS API Reference

◆ PeerVpcAsync()

template<typename PeerVpcRequestT = Model::PeerVpcRequest>
void Aws::Lightsail::LightsailClient::PeerVpcAsync ( const PeerVpcResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const PeerVpcRequestT &  request = {} 
) const
inline

An Async wrapper for PeerVpc that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3924 of file LightsailClient.h.

◆ PeerVpcCallable()

template<typename PeerVpcRequestT = Model::PeerVpcRequest>
Model::PeerVpcOutcomeCallable Aws::Lightsail::LightsailClient::PeerVpcCallable ( const PeerVpcRequestT &  request = {}) const
inline

A Callable wrapper for PeerVpc that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3915 of file LightsailClient.h.

◆ PutAlarm()

virtual Model::PutAlarmOutcome Aws::Lightsail::LightsailClient::PutAlarm ( const Model::PutAlarmRequest request) const
virtual

Creates or updates an alarm, and associates it with the specified metric.

An alarm is used to monitor a single metric for one of your resources. When a metric condition is met, the alarm can notify you by email, SMS text message, and a banner displayed on the Amazon Lightsail console. For more information, see Alarms in Amazon Lightsail.

When this action creates an alarm, the alarm state is immediately set to INSUFFICIENT_DATA. The alarm is then evaluated and its state is set appropriately. Any actions associated with the new state are then executed.

When you update an existing alarm, its state is left unchanged, but the update completely overwrites the previous configuration of the alarm. The alarm is then evaluated with the updated configuration.

See Also:

AWS API Reference

◆ PutAlarmAsync()

template<typename PutAlarmRequestT = Model::PutAlarmRequest>
void Aws::Lightsail::LightsailClient::PutAlarmAsync ( const PutAlarmRequestT &  request,
const PutAlarmResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for PutAlarm that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3961 of file LightsailClient.h.

◆ PutAlarmCallable()

template<typename PutAlarmRequestT = Model::PutAlarmRequest>
Model::PutAlarmOutcomeCallable Aws::Lightsail::LightsailClient::PutAlarmCallable ( const PutAlarmRequestT &  request) const
inline

A Callable wrapper for PutAlarm that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3952 of file LightsailClient.h.

◆ PutInstancePublicPorts()

virtual Model::PutInstancePublicPortsOutcome Aws::Lightsail::LightsailClient::PutInstancePublicPorts ( const Model::PutInstancePublicPortsRequest request) const
virtual

Opens ports for a specific Amazon Lightsail instance, and specifies the IP addresses allowed to connect to the instance through the ports, and the protocol. This action also closes all currently open ports that are not included in the request. Include all of the ports and the protocols you want to open in your PutInstancePublicPortsrequest. Or use the OpenInstancePublicPorts action to open ports without closing currently open ports.

The PutInstancePublicPorts action supports tag-based access control via resource tags applied to the resource identified by instanceName. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ PutInstancePublicPortsAsync()

template<typename PutInstancePublicPortsRequestT = Model::PutInstancePublicPortsRequest>
void Aws::Lightsail::LightsailClient::PutInstancePublicPortsAsync ( const PutInstancePublicPortsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for PutInstancePublicPorts that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3996 of file LightsailClient.h.

◆ PutInstancePublicPortsCallable()

template<typename PutInstancePublicPortsRequestT = Model::PutInstancePublicPortsRequest>
Model::PutInstancePublicPortsOutcomeCallable Aws::Lightsail::LightsailClient::PutInstancePublicPortsCallable ( const PutInstancePublicPortsRequestT &  request) const
inline

A Callable wrapper for PutInstancePublicPorts that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3987 of file LightsailClient.h.

◆ RebootInstance()

virtual Model::RebootInstanceOutcome Aws::Lightsail::LightsailClient::RebootInstance ( const Model::RebootInstanceRequest request) const
virtual

Restarts a specific instance.

The reboot instance operation supports tag-based access control via resource tags applied to the resource identified by instance name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ RebootInstanceAsync()

template<typename RebootInstanceRequestT = Model::RebootInstanceRequest>
void Aws::Lightsail::LightsailClient::RebootInstanceAsync ( const RebootInstanceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for RebootInstance that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4026 of file LightsailClient.h.

◆ RebootInstanceCallable()

template<typename RebootInstanceRequestT = Model::RebootInstanceRequest>
Model::RebootInstanceOutcomeCallable Aws::Lightsail::LightsailClient::RebootInstanceCallable ( const RebootInstanceRequestT &  request) const
inline

A Callable wrapper for RebootInstance that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4017 of file LightsailClient.h.

◆ RebootRelationalDatabase()

virtual Model::RebootRelationalDatabaseOutcome Aws::Lightsail::LightsailClient::RebootRelationalDatabase ( const Model::RebootRelationalDatabaseRequest request) const
virtual

Restarts a specific database in Amazon Lightsail.

The reboot relational database operation supports tag-based access control via resource tags applied to the resource identified by relationalDatabaseName. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ RebootRelationalDatabaseAsync()

template<typename RebootRelationalDatabaseRequestT = Model::RebootRelationalDatabaseRequest>
void Aws::Lightsail::LightsailClient::RebootRelationalDatabaseAsync ( const RebootRelationalDatabaseRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for RebootRelationalDatabase that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4056 of file LightsailClient.h.

◆ RebootRelationalDatabaseCallable()

template<typename RebootRelationalDatabaseRequestT = Model::RebootRelationalDatabaseRequest>
Model::RebootRelationalDatabaseOutcomeCallable Aws::Lightsail::LightsailClient::RebootRelationalDatabaseCallable ( const RebootRelationalDatabaseRequestT &  request) const
inline

A Callable wrapper for RebootRelationalDatabase that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4047 of file LightsailClient.h.

◆ RegisterContainerImage()

virtual Model::RegisterContainerImageOutcome Aws::Lightsail::LightsailClient::RegisterContainerImage ( const Model::RegisterContainerImageRequest request) const
virtual

Registers a container image to your Amazon Lightsail container service.

This action is not required if you install and use the Lightsail Control (lightsailctl) plugin to push container images to your Lightsail container service. For more information, see Pushing and managing container images on your Amazon Lightsail container services in the Amazon Lightsail Developer Guide.

See Also:


AWS API Reference

◆ RegisterContainerImageAsync()

template<typename RegisterContainerImageRequestT = Model::RegisterContainerImageRequest>
void Aws::Lightsail::LightsailClient::RegisterContainerImageAsync ( const RegisterContainerImageRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for RegisterContainerImage that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4088 of file LightsailClient.h.

◆ RegisterContainerImageCallable()

template<typename RegisterContainerImageRequestT = Model::RegisterContainerImageRequest>
Model::RegisterContainerImageOutcomeCallable Aws::Lightsail::LightsailClient::RegisterContainerImageCallable ( const RegisterContainerImageRequestT &  request) const
inline

A Callable wrapper for RegisterContainerImage that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4079 of file LightsailClient.h.

◆ ReleaseStaticIp()

virtual Model::ReleaseStaticIpOutcome Aws::Lightsail::LightsailClient::ReleaseStaticIp ( const Model::ReleaseStaticIpRequest request) const
virtual

Deletes a specific static IP from your account.

See Also:

AWS API Reference

◆ ReleaseStaticIpAsync()

template<typename ReleaseStaticIpRequestT = Model::ReleaseStaticIpRequest>
void Aws::Lightsail::LightsailClient::ReleaseStaticIpAsync ( const ReleaseStaticIpRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ReleaseStaticIp that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4113 of file LightsailClient.h.

◆ ReleaseStaticIpCallable()

template<typename ReleaseStaticIpRequestT = Model::ReleaseStaticIpRequest>
Model::ReleaseStaticIpOutcomeCallable Aws::Lightsail::LightsailClient::ReleaseStaticIpCallable ( const ReleaseStaticIpRequestT &  request) const
inline

A Callable wrapper for ReleaseStaticIp that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4104 of file LightsailClient.h.

◆ ResetDistributionCache()

virtual Model::ResetDistributionCacheOutcome Aws::Lightsail::LightsailClient::ResetDistributionCache ( const Model::ResetDistributionCacheRequest request = {}) const
virtual

Deletes currently cached content from your Amazon Lightsail content delivery network (CDN) distribution.

After resetting the cache, the next time a content request is made, your distribution pulls, serves, and caches it from the origin.

See Also:

AWS API Reference

◆ ResetDistributionCacheAsync()

template<typename ResetDistributionCacheRequestT = Model::ResetDistributionCacheRequest>
void Aws::Lightsail::LightsailClient::ResetDistributionCacheAsync ( const ResetDistributionCacheResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const ResetDistributionCacheRequestT &  request = {} 
) const
inline

An Async wrapper for ResetDistributionCache that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4141 of file LightsailClient.h.

◆ ResetDistributionCacheCallable()

template<typename ResetDistributionCacheRequestT = Model::ResetDistributionCacheRequest>
Model::ResetDistributionCacheOutcomeCallable Aws::Lightsail::LightsailClient::ResetDistributionCacheCallable ( const ResetDistributionCacheRequestT &  request = {}) const
inline

A Callable wrapper for ResetDistributionCache that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4132 of file LightsailClient.h.

◆ SendContactMethodVerification()

virtual Model::SendContactMethodVerificationOutcome Aws::Lightsail::LightsailClient::SendContactMethodVerification ( const Model::SendContactMethodVerificationRequest request) const
virtual

Sends a verification request to an email contact method to ensure it's owned by the requester. SMS contact methods don't need to be verified.

A contact method is used to send you notifications about your Amazon Lightsail resources. You can add one email address and one mobile phone number contact method in each Amazon Web Services Region. However, SMS text messaging is not supported in some Amazon Web Services Regions, and SMS text messages cannot be sent to some countries/regions. For more information, see Notifications in Amazon Lightsail.

A verification request is sent to the contact method when you initially create it. Use this action to send another verification request if a previous verification request was deleted, or has expired.

Notifications are not sent to an email contact method until after it is verified, and confirmed as valid.

See Also:

AWS API Reference

◆ SendContactMethodVerificationAsync()

template<typename SendContactMethodVerificationRequestT = Model::SendContactMethodVerificationRequest>
void Aws::Lightsail::LightsailClient::SendContactMethodVerificationAsync ( const SendContactMethodVerificationRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for SendContactMethodVerification that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4179 of file LightsailClient.h.

◆ SendContactMethodVerificationCallable()

template<typename SendContactMethodVerificationRequestT = Model::SendContactMethodVerificationRequest>
Model::SendContactMethodVerificationOutcomeCallable Aws::Lightsail::LightsailClient::SendContactMethodVerificationCallable ( const SendContactMethodVerificationRequestT &  request) const
inline

A Callable wrapper for SendContactMethodVerification that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4170 of file LightsailClient.h.

◆ SetIpAddressType()

virtual Model::SetIpAddressTypeOutcome Aws::Lightsail::LightsailClient::SetIpAddressType ( const Model::SetIpAddressTypeRequest request) const
virtual

Sets the IP address type for an Amazon Lightsail resource.

Use this action to enable dual-stack for a resource, which enables IPv4 and IPv6 for the specified resource. Alternately, you can use this action to disable dual-stack, and enable IPv4 only.

See Also:

AWS API Reference

◆ SetIpAddressTypeAsync()

template<typename SetIpAddressTypeRequestT = Model::SetIpAddressTypeRequest>
void Aws::Lightsail::LightsailClient::SetIpAddressTypeAsync ( const SetIpAddressTypeRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for SetIpAddressType that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4207 of file LightsailClient.h.

◆ SetIpAddressTypeCallable()

template<typename SetIpAddressTypeRequestT = Model::SetIpAddressTypeRequest>
Model::SetIpAddressTypeOutcomeCallable Aws::Lightsail::LightsailClient::SetIpAddressTypeCallable ( const SetIpAddressTypeRequestT &  request) const
inline

A Callable wrapper for SetIpAddressType that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4198 of file LightsailClient.h.

◆ SetResourceAccessForBucket()

virtual Model::SetResourceAccessForBucketOutcome Aws::Lightsail::LightsailClient::SetResourceAccessForBucket ( const Model::SetResourceAccessForBucketRequest request) const
virtual

Sets the Amazon Lightsail resources that can access the specified Lightsail bucket.

Lightsail buckets currently support setting access for Lightsail instances in the same Amazon Web Services Region.

See Also:

AWS API Reference

◆ SetResourceAccessForBucketAsync()

template<typename SetResourceAccessForBucketRequestT = Model::SetResourceAccessForBucketRequest>
void Aws::Lightsail::LightsailClient::SetResourceAccessForBucketAsync ( const SetResourceAccessForBucketRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for SetResourceAccessForBucket that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4234 of file LightsailClient.h.

◆ SetResourceAccessForBucketCallable()

template<typename SetResourceAccessForBucketRequestT = Model::SetResourceAccessForBucketRequest>
Model::SetResourceAccessForBucketOutcomeCallable Aws::Lightsail::LightsailClient::SetResourceAccessForBucketCallable ( const SetResourceAccessForBucketRequestT &  request) const
inline

A Callable wrapper for SetResourceAccessForBucket that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4225 of file LightsailClient.h.

◆ SetupInstanceHttps()

virtual Model::SetupInstanceHttpsOutcome Aws::Lightsail::LightsailClient::SetupInstanceHttps ( const Model::SetupInstanceHttpsRequest request) const
virtual

Creates an SSL/TLS certificate that secures traffic for your website. After the certificate is created, it is installed on the specified Lightsail instance.

If you provide more than one domain name in the request, at least one name must be less than or equal to 63 characters in length.

See Also:

AWS API Reference

◆ SetupInstanceHttpsAsync()

template<typename SetupInstanceHttpsRequestT = Model::SetupInstanceHttpsRequest>
void Aws::Lightsail::LightsailClient::SetupInstanceHttpsAsync ( const SetupInstanceHttpsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for SetupInstanceHttps that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4263 of file LightsailClient.h.

◆ SetupInstanceHttpsCallable()

template<typename SetupInstanceHttpsRequestT = Model::SetupInstanceHttpsRequest>
Model::SetupInstanceHttpsOutcomeCallable Aws::Lightsail::LightsailClient::SetupInstanceHttpsCallable ( const SetupInstanceHttpsRequestT &  request) const
inline

A Callable wrapper for SetupInstanceHttps that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4254 of file LightsailClient.h.

◆ StartGUISession()

virtual Model::StartGUISessionOutcome Aws::Lightsail::LightsailClient::StartGUISession ( const Model::StartGUISessionRequest request) const
virtual

Initiates a graphical user interface (GUI) session that’s used to access a virtual computer’s operating system and application. The session will be active for 1 hour. Use this action to resume the session after it expires.

See Also:

AWS API Reference

◆ StartGUISessionAsync()

template<typename StartGUISessionRequestT = Model::StartGUISessionRequest>
void Aws::Lightsail::LightsailClient::StartGUISessionAsync ( const StartGUISessionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for StartGUISession that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4291 of file LightsailClient.h.

◆ StartGUISessionCallable()

template<typename StartGUISessionRequestT = Model::StartGUISessionRequest>
Model::StartGUISessionOutcomeCallable Aws::Lightsail::LightsailClient::StartGUISessionCallable ( const StartGUISessionRequestT &  request) const
inline

A Callable wrapper for StartGUISession that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4282 of file LightsailClient.h.

◆ StartInstance()

virtual Model::StartInstanceOutcome Aws::Lightsail::LightsailClient::StartInstance ( const Model::StartInstanceRequest request) const
virtual

Starts a specific Amazon Lightsail instance from a stopped state. To restart an instance, use the reboot instance operation.

When you start a stopped instance, Lightsail assigns a new public IP address to the instance. To use the same IP address after stopping and starting an instance, create a static IP address and attach it to the instance. For more information, see the Amazon Lightsail Developer Guide.

The start instance operation supports tag-based access control via resource tags applied to the resource identified by instance name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ StartInstanceAsync()

template<typename StartInstanceRequestT = Model::StartInstanceRequest>
void Aws::Lightsail::LightsailClient::StartInstanceAsync ( const StartInstanceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for StartInstance that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4328 of file LightsailClient.h.

◆ StartInstanceCallable()

template<typename StartInstanceRequestT = Model::StartInstanceRequest>
Model::StartInstanceOutcomeCallable Aws::Lightsail::LightsailClient::StartInstanceCallable ( const StartInstanceRequestT &  request) const
inline

A Callable wrapper for StartInstance that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4319 of file LightsailClient.h.

◆ StartRelationalDatabase()

virtual Model::StartRelationalDatabaseOutcome Aws::Lightsail::LightsailClient::StartRelationalDatabase ( const Model::StartRelationalDatabaseRequest request) const
virtual

Starts a specific database from a stopped state in Amazon Lightsail. To restart a database, use the reboot relational database operation.

The start relational database operation supports tag-based access control via resource tags applied to the resource identified by relationalDatabaseName. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ StartRelationalDatabaseAsync()

template<typename StartRelationalDatabaseRequestT = Model::StartRelationalDatabaseRequest>
void Aws::Lightsail::LightsailClient::StartRelationalDatabaseAsync ( const StartRelationalDatabaseRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for StartRelationalDatabase that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4359 of file LightsailClient.h.

◆ StartRelationalDatabaseCallable()

template<typename StartRelationalDatabaseRequestT = Model::StartRelationalDatabaseRequest>
Model::StartRelationalDatabaseOutcomeCallable Aws::Lightsail::LightsailClient::StartRelationalDatabaseCallable ( const StartRelationalDatabaseRequestT &  request) const
inline

A Callable wrapper for StartRelationalDatabase that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4350 of file LightsailClient.h.

◆ StopGUISession()

virtual Model::StopGUISessionOutcome Aws::Lightsail::LightsailClient::StopGUISession ( const Model::StopGUISessionRequest request) const
virtual

Terminates a web-based NICE DCV session that’s used to access a virtual computer’s operating system or application. The session will close and any unsaved data will be lost.

See Also:

AWS API Reference

◆ StopGUISessionAsync()

template<typename StopGUISessionRequestT = Model::StopGUISessionRequest>
void Aws::Lightsail::LightsailClient::StopGUISessionAsync ( const StopGUISessionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for StopGUISession that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4386 of file LightsailClient.h.

◆ StopGUISessionCallable()

template<typename StopGUISessionRequestT = Model::StopGUISessionRequest>
Model::StopGUISessionOutcomeCallable Aws::Lightsail::LightsailClient::StopGUISessionCallable ( const StopGUISessionRequestT &  request) const
inline

A Callable wrapper for StopGUISession that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4377 of file LightsailClient.h.

◆ StopInstance()

virtual Model::StopInstanceOutcome Aws::Lightsail::LightsailClient::StopInstance ( const Model::StopInstanceRequest request) const
virtual

Stops a specific Amazon Lightsail instance that is currently running.

When you start a stopped instance, Lightsail assigns a new public IP address to the instance. To use the same IP address after stopping and starting an instance, create a static IP address and attach it to the instance. For more information, see the Amazon Lightsail Developer Guide.

The stop instance operation supports tag-based access control via resource tags applied to the resource identified by instance name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ StopInstanceAsync()

template<typename StopInstanceRequestT = Model::StopInstanceRequest>
void Aws::Lightsail::LightsailClient::StopInstanceAsync ( const StopInstanceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for StopInstance that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4422 of file LightsailClient.h.

◆ StopInstanceCallable()

template<typename StopInstanceRequestT = Model::StopInstanceRequest>
Model::StopInstanceOutcomeCallable Aws::Lightsail::LightsailClient::StopInstanceCallable ( const StopInstanceRequestT &  request) const
inline

A Callable wrapper for StopInstance that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4413 of file LightsailClient.h.

◆ StopRelationalDatabase()

virtual Model::StopRelationalDatabaseOutcome Aws::Lightsail::LightsailClient::StopRelationalDatabase ( const Model::StopRelationalDatabaseRequest request) const
virtual

Stops a specific database that is currently running in Amazon Lightsail.

The stop relational database operation supports tag-based access control via resource tags applied to the resource identified by relationalDatabaseName. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ StopRelationalDatabaseAsync()

template<typename StopRelationalDatabaseRequestT = Model::StopRelationalDatabaseRequest>
void Aws::Lightsail::LightsailClient::StopRelationalDatabaseAsync ( const StopRelationalDatabaseRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for StopRelationalDatabase that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4452 of file LightsailClient.h.

◆ StopRelationalDatabaseCallable()

template<typename StopRelationalDatabaseRequestT = Model::StopRelationalDatabaseRequest>
Model::StopRelationalDatabaseOutcomeCallable Aws::Lightsail::LightsailClient::StopRelationalDatabaseCallable ( const StopRelationalDatabaseRequestT &  request) const
inline

A Callable wrapper for StopRelationalDatabase that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4443 of file LightsailClient.h.

◆ TagResource()

virtual Model::TagResourceOutcome Aws::Lightsail::LightsailClient::TagResource ( const Model::TagResourceRequest request) const
virtual

Adds one or more tags to the specified Amazon Lightsail resource. Each resource can have a maximum of 50 tags. Each tag consists of a key and an optional value. Tag keys must be unique per resource. For more information about tags, see the Amazon Lightsail Developer Guide.

The tag resource operation supports tag-based access control via request tags and resource tags applied to the resource identified by resource name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ TagResourceAsync()

template<typename TagResourceRequestT = Model::TagResourceRequest>
void Aws::Lightsail::LightsailClient::TagResourceAsync ( const TagResourceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4487 of file LightsailClient.h.

◆ TagResourceCallable()

template<typename TagResourceRequestT = Model::TagResourceRequest>
Model::TagResourceOutcomeCallable Aws::Lightsail::LightsailClient::TagResourceCallable ( const TagResourceRequestT &  request) const
inline

A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4478 of file LightsailClient.h.

◆ TestAlarm()

virtual Model::TestAlarmOutcome Aws::Lightsail::LightsailClient::TestAlarm ( const Model::TestAlarmRequest request) const
virtual

Tests an alarm by displaying a banner on the Amazon Lightsail console. If a notification trigger is configured for the specified alarm, the test also sends a notification to the notification protocol (Email and/or SMS) configured for the alarm.

An alarm is used to monitor a single metric for one of your resources. When a metric condition is met, the alarm can notify you by email, SMS text message, and a banner displayed on the Amazon Lightsail console. For more information, see Alarms in Amazon Lightsail.

See Also:

AWS API Reference

◆ TestAlarmAsync()

template<typename TestAlarmRequestT = Model::TestAlarmRequest>
void Aws::Lightsail::LightsailClient::TestAlarmAsync ( const TestAlarmRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for TestAlarm that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4520 of file LightsailClient.h.

◆ TestAlarmCallable()

template<typename TestAlarmRequestT = Model::TestAlarmRequest>
Model::TestAlarmOutcomeCallable Aws::Lightsail::LightsailClient::TestAlarmCallable ( const TestAlarmRequestT &  request) const
inline

A Callable wrapper for TestAlarm that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4511 of file LightsailClient.h.

◆ UnpeerVpc()

virtual Model::UnpeerVpcOutcome Aws::Lightsail::LightsailClient::UnpeerVpc ( const Model::UnpeerVpcRequest request = {}) const
virtual

Unpeers the Lightsail VPC from the user's default VPC.

See Also:

AWS API Reference

◆ UnpeerVpcAsync()

template<typename UnpeerVpcRequestT = Model::UnpeerVpcRequest>
void Aws::Lightsail::LightsailClient::UnpeerVpcAsync ( const UnpeerVpcResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const UnpeerVpcRequestT &  request = {} 
) const
inline

An Async wrapper for UnpeerVpc that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4546 of file LightsailClient.h.

◆ UnpeerVpcCallable()

template<typename UnpeerVpcRequestT = Model::UnpeerVpcRequest>
Model::UnpeerVpcOutcomeCallable Aws::Lightsail::LightsailClient::UnpeerVpcCallable ( const UnpeerVpcRequestT &  request = {}) const
inline

A Callable wrapper for UnpeerVpc that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4537 of file LightsailClient.h.

◆ UntagResource()

virtual Model::UntagResourceOutcome Aws::Lightsail::LightsailClient::UntagResource ( const Model::UntagResourceRequest request) const
virtual

Deletes the specified set of tag keys and their values from the specified Amazon Lightsail resource.

The untag resource operation supports tag-based access control via request tags and resource tags applied to the resource identified by resource name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ UntagResourceAsync()

template<typename UntagResourceRequestT = Model::UntagResourceRequest>
void Aws::Lightsail::LightsailClient::UntagResourceAsync ( const UntagResourceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4577 of file LightsailClient.h.

◆ UntagResourceCallable()

template<typename UntagResourceRequestT = Model::UntagResourceRequest>
Model::UntagResourceOutcomeCallable Aws::Lightsail::LightsailClient::UntagResourceCallable ( const UntagResourceRequestT &  request) const
inline

A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4568 of file LightsailClient.h.

◆ UpdateBucket()

virtual Model::UpdateBucketOutcome Aws::Lightsail::LightsailClient::UpdateBucket ( const Model::UpdateBucketRequest request) const
virtual

Updates an existing Amazon Lightsail bucket.

Use this action to update the configuration of an existing bucket, such as versioning, public accessibility, and the Amazon Web Services accounts that can access the bucket.

See Also:

AWS API Reference

◆ UpdateBucketAsync()

template<typename UpdateBucketRequestT = Model::UpdateBucketRequest>
void Aws::Lightsail::LightsailClient::UpdateBucketAsync ( const UpdateBucketRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateBucket that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4605 of file LightsailClient.h.

◆ UpdateBucketBundle()

virtual Model::UpdateBucketBundleOutcome Aws::Lightsail::LightsailClient::UpdateBucketBundle ( const Model::UpdateBucketBundleRequest request) const
virtual

Updates the bundle, or storage plan, of an existing Amazon Lightsail bucket.

A bucket bundle specifies the monthly cost, storage space, and data transfer quota for a bucket. You can update a bucket's bundle only one time within a monthly Amazon Web Services billing cycle. To determine if you can update a bucket's bundle, use the GetBuckets action. The ableToUpdateBundle parameter in the response will indicate whether you can currently update a bucket's bundle.

Update a bucket's bundle if it's consistently going over its storage space or data transfer quota, or if a bucket's usage is consistently in the lower range of its storage space or data transfer quota. Due to the unpredictable usage fluctuations that a bucket might experience, we strongly recommend that you update a bucket's bundle only as a long-term strategy, instead of as a short-term, monthly cost-cutting measure. Choose a bucket bundle that will provide the bucket with ample storage space and data transfer for a long time to come.

See Also:

AWS API Reference

◆ UpdateBucketBundleAsync()

template<typename UpdateBucketBundleRequestT = Model::UpdateBucketBundleRequest>
void Aws::Lightsail::LightsailClient::UpdateBucketBundleAsync ( const UpdateBucketBundleRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateBucketBundle that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4645 of file LightsailClient.h.

◆ UpdateBucketBundleCallable()

template<typename UpdateBucketBundleRequestT = Model::UpdateBucketBundleRequest>
Model::UpdateBucketBundleOutcomeCallable Aws::Lightsail::LightsailClient::UpdateBucketBundleCallable ( const UpdateBucketBundleRequestT &  request) const
inline

A Callable wrapper for UpdateBucketBundle that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4636 of file LightsailClient.h.

◆ UpdateBucketCallable()

template<typename UpdateBucketRequestT = Model::UpdateBucketRequest>
Model::UpdateBucketOutcomeCallable Aws::Lightsail::LightsailClient::UpdateBucketCallable ( const UpdateBucketRequestT &  request) const
inline

A Callable wrapper for UpdateBucket that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4596 of file LightsailClient.h.

◆ UpdateContainerService()

virtual Model::UpdateContainerServiceOutcome Aws::Lightsail::LightsailClient::UpdateContainerService ( const Model::UpdateContainerServiceRequest request) const
virtual

Updates the configuration of your Amazon Lightsail container service, such as its power, scale, and public domain names.

See Also:

AWS API Reference

◆ UpdateContainerServiceAsync()

template<typename UpdateContainerServiceRequestT = Model::UpdateContainerServiceRequest>
void Aws::Lightsail::LightsailClient::UpdateContainerServiceAsync ( const UpdateContainerServiceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateContainerService that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4671 of file LightsailClient.h.

◆ UpdateContainerServiceCallable()

template<typename UpdateContainerServiceRequestT = Model::UpdateContainerServiceRequest>
Model::UpdateContainerServiceOutcomeCallable Aws::Lightsail::LightsailClient::UpdateContainerServiceCallable ( const UpdateContainerServiceRequestT &  request) const
inline

A Callable wrapper for UpdateContainerService that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4662 of file LightsailClient.h.

◆ UpdateDistribution()

virtual Model::UpdateDistributionOutcome Aws::Lightsail::LightsailClient::UpdateDistribution ( const Model::UpdateDistributionRequest request) const
virtual

Updates an existing Amazon Lightsail content delivery network (CDN) distribution.

Use this action to update the configuration of your existing distribution.

See Also:

AWS API Reference

◆ UpdateDistributionAsync()

template<typename UpdateDistributionRequestT = Model::UpdateDistributionRequest>
void Aws::Lightsail::LightsailClient::UpdateDistributionAsync ( const UpdateDistributionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateDistribution that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4698 of file LightsailClient.h.

◆ UpdateDistributionBundle()

virtual Model::UpdateDistributionBundleOutcome Aws::Lightsail::LightsailClient::UpdateDistributionBundle ( const Model::UpdateDistributionBundleRequest request = {}) const
virtual

Updates the bundle of your Amazon Lightsail content delivery network (CDN) distribution.

A distribution bundle specifies the monthly network transfer quota and monthly cost of your distribution.

Update your distribution's bundle if your distribution is going over its monthly network transfer quota and is incurring an overage fee.

You can update your distribution's bundle only one time within your monthly Amazon Web Services billing cycle. To determine if you can update your distribution's bundle, use the GetDistributions action. The ableToUpdateBundle parameter in the result will indicate whether you can currently update your distribution's bundle.

See Also:

AWS API Reference

◆ UpdateDistributionBundleAsync()

template<typename UpdateDistributionBundleRequestT = Model::UpdateDistributionBundleRequest>
void Aws::Lightsail::LightsailClient::UpdateDistributionBundleAsync ( const UpdateDistributionBundleResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const UpdateDistributionBundleRequestT &  request = {} 
) const
inline

An Async wrapper for UpdateDistributionBundle that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4732 of file LightsailClient.h.

◆ UpdateDistributionBundleCallable()

template<typename UpdateDistributionBundleRequestT = Model::UpdateDistributionBundleRequest>
Model::UpdateDistributionBundleOutcomeCallable Aws::Lightsail::LightsailClient::UpdateDistributionBundleCallable ( const UpdateDistributionBundleRequestT &  request = {}) const
inline

A Callable wrapper for UpdateDistributionBundle that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4723 of file LightsailClient.h.

◆ UpdateDistributionCallable()

template<typename UpdateDistributionRequestT = Model::UpdateDistributionRequest>
Model::UpdateDistributionOutcomeCallable Aws::Lightsail::LightsailClient::UpdateDistributionCallable ( const UpdateDistributionRequestT &  request) const
inline

A Callable wrapper for UpdateDistribution that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4689 of file LightsailClient.h.

◆ UpdateDomainEntry()

virtual Model::UpdateDomainEntryOutcome Aws::Lightsail::LightsailClient::UpdateDomainEntry ( const Model::UpdateDomainEntryRequest request) const
virtual

Updates a domain recordset after it is created.

The update domain entry operation supports tag-based access control via resource tags applied to the resource identified by domain name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ UpdateDomainEntryAsync()

template<typename UpdateDomainEntryRequestT = Model::UpdateDomainEntryRequest>
void Aws::Lightsail::LightsailClient::UpdateDomainEntryAsync ( const UpdateDomainEntryRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateDomainEntry that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4762 of file LightsailClient.h.

◆ UpdateDomainEntryCallable()

template<typename UpdateDomainEntryRequestT = Model::UpdateDomainEntryRequest>
Model::UpdateDomainEntryOutcomeCallable Aws::Lightsail::LightsailClient::UpdateDomainEntryCallable ( const UpdateDomainEntryRequestT &  request) const
inline

A Callable wrapper for UpdateDomainEntry that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4753 of file LightsailClient.h.

◆ UpdateInstanceMetadataOptions()

virtual Model::UpdateInstanceMetadataOptionsOutcome Aws::Lightsail::LightsailClient::UpdateInstanceMetadataOptions ( const Model::UpdateInstanceMetadataOptionsRequest request) const
virtual

Modifies the Amazon Lightsail instance metadata parameters on a running or stopped instance. When you modify the parameters on a running instance, the GetInstance or GetInstances API operation initially responds with a state of pending. After the parameter modifications are successfully applied, the state changes to applied in subsequent GetInstance or GetInstances API calls. For more information, see Use IMDSv2 with an Amazon Lightsail instance in the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ UpdateInstanceMetadataOptionsAsync()

template<typename UpdateInstanceMetadataOptionsRequestT = Model::UpdateInstanceMetadataOptionsRequest>
void Aws::Lightsail::LightsailClient::UpdateInstanceMetadataOptionsAsync ( const UpdateInstanceMetadataOptionsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateInstanceMetadataOptions that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4796 of file LightsailClient.h.

◆ UpdateInstanceMetadataOptionsCallable()

template<typename UpdateInstanceMetadataOptionsRequestT = Model::UpdateInstanceMetadataOptionsRequest>
Model::UpdateInstanceMetadataOptionsOutcomeCallable Aws::Lightsail::LightsailClient::UpdateInstanceMetadataOptionsCallable ( const UpdateInstanceMetadataOptionsRequestT &  request) const
inline

A Callable wrapper for UpdateInstanceMetadataOptions that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4787 of file LightsailClient.h.

◆ UpdateLoadBalancerAttribute()

virtual Model::UpdateLoadBalancerAttributeOutcome Aws::Lightsail::LightsailClient::UpdateLoadBalancerAttribute ( const Model::UpdateLoadBalancerAttributeRequest request) const
virtual

Updates the specified attribute for a load balancer. You can only update one attribute at a time.

The update load balancer attribute operation supports tag-based access control via resource tags applied to the resource identified by load balancer name. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ UpdateLoadBalancerAttributeAsync()

template<typename UpdateLoadBalancerAttributeRequestT = Model::UpdateLoadBalancerAttributeRequest>
void Aws::Lightsail::LightsailClient::UpdateLoadBalancerAttributeAsync ( const UpdateLoadBalancerAttributeRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateLoadBalancerAttribute that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4827 of file LightsailClient.h.

◆ UpdateLoadBalancerAttributeCallable()

template<typename UpdateLoadBalancerAttributeRequestT = Model::UpdateLoadBalancerAttributeRequest>
Model::UpdateLoadBalancerAttributeOutcomeCallable Aws::Lightsail::LightsailClient::UpdateLoadBalancerAttributeCallable ( const UpdateLoadBalancerAttributeRequestT &  request) const
inline

A Callable wrapper for UpdateLoadBalancerAttribute that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4818 of file LightsailClient.h.

◆ UpdateRelationalDatabase()

virtual Model::UpdateRelationalDatabaseOutcome Aws::Lightsail::LightsailClient::UpdateRelationalDatabase ( const Model::UpdateRelationalDatabaseRequest request) const
virtual

Allows the update of one or more attributes of a database in Amazon Lightsail.

Updates are applied immediately, or in cases where the updates could result in an outage, are applied during the database's predefined maintenance window.

The update relational database operation supports tag-based access control via resource tags applied to the resource identified by relationalDatabaseName. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ UpdateRelationalDatabaseAsync()

template<typename UpdateRelationalDatabaseRequestT = Model::UpdateRelationalDatabaseRequest>
void Aws::Lightsail::LightsailClient::UpdateRelationalDatabaseAsync ( const UpdateRelationalDatabaseRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateRelationalDatabase that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4859 of file LightsailClient.h.

◆ UpdateRelationalDatabaseCallable()

template<typename UpdateRelationalDatabaseRequestT = Model::UpdateRelationalDatabaseRequest>
Model::UpdateRelationalDatabaseOutcomeCallable Aws::Lightsail::LightsailClient::UpdateRelationalDatabaseCallable ( const UpdateRelationalDatabaseRequestT &  request) const
inline

A Callable wrapper for UpdateRelationalDatabase that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4850 of file LightsailClient.h.

◆ UpdateRelationalDatabaseParameters()

virtual Model::UpdateRelationalDatabaseParametersOutcome Aws::Lightsail::LightsailClient::UpdateRelationalDatabaseParameters ( const Model::UpdateRelationalDatabaseParametersRequest request) const
virtual

Allows the update of one or more parameters of a database in Amazon Lightsail.

Parameter updates don't cause outages; therefore, their application is not subject to the preferred maintenance window. However, there are two ways in which parameter updates are applied: dynamic or pending-reboot. Parameters marked with a dynamic apply type are applied immediately. Parameters marked with a pending-reboot apply type are applied only after the database is rebooted using the reboot relational database operation.

The update relational database parameters operation supports tag-based access control via resource tags applied to the resource identified by relationalDatabaseName. For more information, see the Amazon Lightsail Developer Guide.

See Also:

AWS API Reference

◆ UpdateRelationalDatabaseParametersAsync()

template<typename UpdateRelationalDatabaseParametersRequestT = Model::UpdateRelationalDatabaseParametersRequest>
void Aws::Lightsail::LightsailClient::UpdateRelationalDatabaseParametersAsync ( const UpdateRelationalDatabaseParametersRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateRelationalDatabaseParameters that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4896 of file LightsailClient.h.

◆ UpdateRelationalDatabaseParametersCallable()

template<typename UpdateRelationalDatabaseParametersRequestT = Model::UpdateRelationalDatabaseParametersRequest>
Model::UpdateRelationalDatabaseParametersOutcomeCallable Aws::Lightsail::LightsailClient::UpdateRelationalDatabaseParametersCallable ( const UpdateRelationalDatabaseParametersRequestT &  request) const
inline

A Callable wrapper for UpdateRelationalDatabaseParameters that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4887 of file LightsailClient.h.

Friends And Related Symbol Documentation

◆ Aws::Client::ClientWithAsyncTemplateMethods< LightsailClient >

Definition at line 4903 of file LightsailClient.h.


The documentation for this class was generated from the following file: