ProductionVariant.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/sagemaker/SageMaker_EXPORTS.h>
#include <aws/sagemaker/model/InstancePool.h>
#include <aws/sagemaker/model/ProductionVariantAcceleratorType.h>
#include <aws/sagemaker/model/ProductionVariantCapacityReservationConfig.h>
#include <aws/sagemaker/model/ProductionVariantCoreDumpConfig.h>
#include <aws/sagemaker/model/ProductionVariantInferenceAmiVersion.h>
#include <aws/sagemaker/model/ProductionVariantInstanceType.h>
#include <aws/sagemaker/model/ProductionVariantManagedInstanceScaling.h>
#include <aws/sagemaker/model/ProductionVariantRoutingConfig.h>
#include <aws/sagemaker/model/ProductionVariantServerlessConfig.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace SageMaker {
namespace Model {
 
class ProductionVariant {
 public:
  AWS_SAGEMAKER_API ProductionVariant() = default;
  AWS_SAGEMAKER_API ProductionVariant(Aws::Utils::Json::JsonView jsonValue);
  AWS_SAGEMAKER_API ProductionVariant& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_SAGEMAKER_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetVariantName() const { return m_variantName; }
  inline bool VariantNameHasBeenSet() const { return m_variantNameHasBeenSet; }
  template <typename VariantNameT = Aws::String>
  void SetVariantName(VariantNameT&& value) {
    m_variantNameHasBeenSet = true;
    m_variantName = std::forward<VariantNameT>(value);
  }
  template <typename VariantNameT = Aws::String>
  ProductionVariant& WithVariantName(VariantNameT&& value) {
    SetVariantName(std::forward<VariantNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetModelName() const { return m_modelName; }
  inline bool ModelNameHasBeenSet() const { return m_modelNameHasBeenSet; }
  template <typename ModelNameT = Aws::String>
  void SetModelName(ModelNameT&& value) {
    m_modelNameHasBeenSet = true;
    m_modelName = std::forward<ModelNameT>(value);
  }
  template <typename ModelNameT = Aws::String>
  ProductionVariant& WithModelName(ModelNameT&& value) {
    SetModelName(std::forward<ModelNameT>(value));
    return *this;
  }
 
 
  inline int GetInitialInstanceCount() const { return m_initialInstanceCount; }
  inline bool InitialInstanceCountHasBeenSet() const { return m_initialInstanceCountHasBeenSet; }
  inline void SetInitialInstanceCount(int value) {
    m_initialInstanceCountHasBeenSet = true;
    m_initialInstanceCount = value;
  }
  inline ProductionVariant& WithInitialInstanceCount(int value) {
    SetInitialInstanceCount(value);
    return *this;
  }
 
 
  inline ProductionVariantInstanceType GetInstanceType() const { return m_instanceType; }
  inline bool InstanceTypeHasBeenSet() const { return m_instanceTypeHasBeenSet; }
  inline void SetInstanceType(ProductionVariantInstanceType value) {
    m_instanceTypeHasBeenSet = true;
    m_instanceType = value;
  }
  inline ProductionVariant& WithInstanceType(ProductionVariantInstanceType value) {
    SetInstanceType(value);
    return *this;
  }
 
 
  inline const Aws::Vector<InstancePool>& GetInstancePools() const { return m_instancePools; }
  inline bool InstancePoolsHasBeenSet() const { return m_instancePoolsHasBeenSet; }
  template <typename InstancePoolsT = Aws::Vector<InstancePool>>
  void SetInstancePools(InstancePoolsT&& value) {
    m_instancePoolsHasBeenSet = true;
    m_instancePools = std::forward<InstancePoolsT>(value);
  }
  template <typename InstancePoolsT = Aws::Vector<InstancePool>>
  ProductionVariant& WithInstancePools(InstancePoolsT&& value) {
    SetInstancePools(std::forward<InstancePoolsT>(value));
    return *this;
  }
  template <typename InstancePoolsT = InstancePool>
  ProductionVariant& AddInstancePools(InstancePoolsT&& value) {
    m_instancePoolsHasBeenSet = true;
    m_instancePools.emplace_back(std::forward<InstancePoolsT>(value));
    return *this;
  }
 
 
  inline int GetVariantInstanceProvisionTimeoutInSeconds() const { return m_variantInstanceProvisionTimeoutInSeconds; }
  inline bool VariantInstanceProvisionTimeoutInSecondsHasBeenSet() const { return m_variantInstanceProvisionTimeoutInSecondsHasBeenSet; }
  inline void SetVariantInstanceProvisionTimeoutInSeconds(int value) {
    m_variantInstanceProvisionTimeoutInSecondsHasBeenSet = true;
    m_variantInstanceProvisionTimeoutInSeconds = value;
  }
  inline ProductionVariant& WithVariantInstanceProvisionTimeoutInSeconds(int value) {
    SetVariantInstanceProvisionTimeoutInSeconds(value);
    return *this;
  }
 
 
  inline double GetInitialVariantWeight() const { return m_initialVariantWeight; }
  inline bool InitialVariantWeightHasBeenSet() const { return m_initialVariantWeightHasBeenSet; }
  inline void SetInitialVariantWeight(double value) {
    m_initialVariantWeightHasBeenSet = true;
    m_initialVariantWeight = value;
  }
  inline ProductionVariant& WithInitialVariantWeight(double value) {
    SetInitialVariantWeight(value);
    return *this;
  }
 
 
  inline ProductionVariantAcceleratorType GetAcceleratorType() const { return m_acceleratorType; }
  inline bool AcceleratorTypeHasBeenSet() const { return m_acceleratorTypeHasBeenSet; }
  inline void SetAcceleratorType(ProductionVariantAcceleratorType value) {
    m_acceleratorTypeHasBeenSet = true;
    m_acceleratorType = value;
  }
  inline ProductionVariant& WithAcceleratorType(ProductionVariantAcceleratorType value) {
    SetAcceleratorType(value);
    return *this;
  }
 
 
  inline const ProductionVariantCoreDumpConfig& GetCoreDumpConfig() const { return m_coreDumpConfig; }
  inline bool CoreDumpConfigHasBeenSet() const { return m_coreDumpConfigHasBeenSet; }
  template <typename CoreDumpConfigT = ProductionVariantCoreDumpConfig>
  void SetCoreDumpConfig(CoreDumpConfigT&& value) {
    m_coreDumpConfigHasBeenSet = true;
    m_coreDumpConfig = std::forward<CoreDumpConfigT>(value);
  }
  template <typename CoreDumpConfigT = ProductionVariantCoreDumpConfig>
  ProductionVariant& WithCoreDumpConfig(CoreDumpConfigT&& value) {
    SetCoreDumpConfig(std::forward<CoreDumpConfigT>(value));
    return *this;
  }
 
 
  inline const ProductionVariantServerlessConfig& GetServerlessConfig() const { return m_serverlessConfig; }
  inline bool ServerlessConfigHasBeenSet() const { return m_serverlessConfigHasBeenSet; }
  template <typename ServerlessConfigT = ProductionVariantServerlessConfig>
  void SetServerlessConfig(ServerlessConfigT&& value) {
    m_serverlessConfigHasBeenSet = true;
    m_serverlessConfig = std::forward<ServerlessConfigT>(value);
  }
  template <typename ServerlessConfigT = ProductionVariantServerlessConfig>
  ProductionVariant& WithServerlessConfig(ServerlessConfigT&& value) {
    SetServerlessConfig(std::forward<ServerlessConfigT>(value));
    return *this;
  }
 
 
  inline int GetVolumeSizeInGB() const { return m_volumeSizeInGB; }
  inline bool VolumeSizeInGBHasBeenSet() const { return m_volumeSizeInGBHasBeenSet; }
  inline void SetVolumeSizeInGB(int value) {
    m_volumeSizeInGBHasBeenSet = true;
    m_volumeSizeInGB = value;
  }
  inline ProductionVariant& WithVolumeSizeInGB(int value) {
    SetVolumeSizeInGB(value);
    return *this;
  }
 
 
  inline int GetModelDataDownloadTimeoutInSeconds() const { return m_modelDataDownloadTimeoutInSeconds; }
  inline bool ModelDataDownloadTimeoutInSecondsHasBeenSet() const { return m_modelDataDownloadTimeoutInSecondsHasBeenSet; }
  inline void SetModelDataDownloadTimeoutInSeconds(int value) {
    m_modelDataDownloadTimeoutInSecondsHasBeenSet = true;
    m_modelDataDownloadTimeoutInSeconds = value;
  }
  inline ProductionVariant& WithModelDataDownloadTimeoutInSeconds(int value) {
    SetModelDataDownloadTimeoutInSeconds(value);
    return *this;
  }
 
 
  inline int GetContainerStartupHealthCheckTimeoutInSeconds() const { return m_containerStartupHealthCheckTimeoutInSeconds; }
  inline bool ContainerStartupHealthCheckTimeoutInSecondsHasBeenSet() const {
    return m_containerStartupHealthCheckTimeoutInSecondsHasBeenSet;
  }
  inline void SetContainerStartupHealthCheckTimeoutInSeconds(int value) {
    m_containerStartupHealthCheckTimeoutInSecondsHasBeenSet = true;
    m_containerStartupHealthCheckTimeoutInSeconds = value;
  }
  inline ProductionVariant& WithContainerStartupHealthCheckTimeoutInSeconds(int value) {
    SetContainerStartupHealthCheckTimeoutInSeconds(value);
    return *this;
  }
 
 
  inline bool GetEnableSSMAccess() const { return m_enableSSMAccess; }
  inline bool EnableSSMAccessHasBeenSet() const { return m_enableSSMAccessHasBeenSet; }
  inline void SetEnableSSMAccess(bool value) {
    m_enableSSMAccessHasBeenSet = true;
    m_enableSSMAccess = value;
  }
  inline ProductionVariant& WithEnableSSMAccess(bool value) {
    SetEnableSSMAccess(value);
    return *this;
  }
 
 
  inline const ProductionVariantManagedInstanceScaling& GetManagedInstanceScaling() const { return m_managedInstanceScaling; }
  inline bool ManagedInstanceScalingHasBeenSet() const { return m_managedInstanceScalingHasBeenSet; }
  template <typename ManagedInstanceScalingT = ProductionVariantManagedInstanceScaling>
  void SetManagedInstanceScaling(ManagedInstanceScalingT&& value) {
    m_managedInstanceScalingHasBeenSet = true;
    m_managedInstanceScaling = std::forward<ManagedInstanceScalingT>(value);
  }
  template <typename ManagedInstanceScalingT = ProductionVariantManagedInstanceScaling>
  ProductionVariant& WithManagedInstanceScaling(ManagedInstanceScalingT&& value) {
    SetManagedInstanceScaling(std::forward<ManagedInstanceScalingT>(value));
    return *this;
  }
 
 
  inline const ProductionVariantRoutingConfig& GetRoutingConfig() const { return m_routingConfig; }
  inline bool RoutingConfigHasBeenSet() const { return m_routingConfigHasBeenSet; }
  template <typename RoutingConfigT = ProductionVariantRoutingConfig>
  void SetRoutingConfig(RoutingConfigT&& value) {
    m_routingConfigHasBeenSet = true;
    m_routingConfig = std::forward<RoutingConfigT>(value);
  }
  template <typename RoutingConfigT = ProductionVariantRoutingConfig>
  ProductionVariant& WithRoutingConfig(RoutingConfigT&& value) {
    SetRoutingConfig(std::forward<RoutingConfigT>(value));
    return *this;
  }
 
 
  inline ProductionVariantInferenceAmiVersion GetInferenceAmiVersion() const { return m_inferenceAmiVersion; }
  inline bool InferenceAmiVersionHasBeenSet() const { return m_inferenceAmiVersionHasBeenSet; }
  inline void SetInferenceAmiVersion(ProductionVariantInferenceAmiVersion value) {
    m_inferenceAmiVersionHasBeenSet = true;
    m_inferenceAmiVersion = value;
  }
  inline ProductionVariant& WithInferenceAmiVersion(ProductionVariantInferenceAmiVersion value) {
    SetInferenceAmiVersion(value);
    return *this;
  }
 
 
  inline const ProductionVariantCapacityReservationConfig& GetCapacityReservationConfig() const { return m_capacityReservationConfig; }
  inline bool CapacityReservationConfigHasBeenSet() const { return m_capacityReservationConfigHasBeenSet; }
  template <typename CapacityReservationConfigT = ProductionVariantCapacityReservationConfig>
  void SetCapacityReservationConfig(CapacityReservationConfigT&& value) {
    m_capacityReservationConfigHasBeenSet = true;
    m_capacityReservationConfig = std::forward<CapacityReservationConfigT>(value);
  }
  template <typename CapacityReservationConfigT = ProductionVariantCapacityReservationConfig>
  ProductionVariant& WithCapacityReservationConfig(CapacityReservationConfigT&& value) {
    SetCapacityReservationConfig(std::forward<CapacityReservationConfigT>(value));
    return *this;
  }
 private:
  Aws::String m_variantName;
 
  Aws::String m_modelName;
 
  int m_initialInstanceCount{0};
 
  ProductionVariantInstanceType m_instanceType{ProductionVariantInstanceType::NOT_SET};
 
  Aws::Vector<InstancePool> m_instancePools;
 
  int m_variantInstanceProvisionTimeoutInSeconds{0};
 
  double m_initialVariantWeight{0.0};
 
  ProductionVariantAcceleratorType m_acceleratorType{ProductionVariantAcceleratorType::NOT_SET};
 
  ProductionVariantCoreDumpConfig m_coreDumpConfig;
 
  ProductionVariantServerlessConfig m_serverlessConfig;
 
  int m_volumeSizeInGB{0};
 
  int m_modelDataDownloadTimeoutInSeconds{0};
 
  int m_containerStartupHealthCheckTimeoutInSeconds{0};
 
  bool m_enableSSMAccess{false};
 
  ProductionVariantManagedInstanceScaling m_managedInstanceScaling;
 
  ProductionVariantRoutingConfig m_routingConfig;
 
  ProductionVariantInferenceAmiVersion m_inferenceAmiVersion{ProductionVariantInferenceAmiVersion::NOT_SET};
 
  ProductionVariantCapacityReservationConfig m_capacityReservationConfig;
  bool m_variantNameHasBeenSet = false;
  bool m_modelNameHasBeenSet = false;
  bool m_initialInstanceCountHasBeenSet = false;
  bool m_instanceTypeHasBeenSet = false;
  bool m_instancePoolsHasBeenSet = false;
  bool m_variantInstanceProvisionTimeoutInSecondsHasBeenSet = false;
  bool m_initialVariantWeightHasBeenSet = false;
  bool m_acceleratorTypeHasBeenSet = false;
  bool m_coreDumpConfigHasBeenSet = false;
  bool m_serverlessConfigHasBeenSet = false;
  bool m_volumeSizeInGBHasBeenSet = false;
  bool m_modelDataDownloadTimeoutInSecondsHasBeenSet = false;
  bool m_containerStartupHealthCheckTimeoutInSecondsHasBeenSet = false;
  bool m_enableSSMAccessHasBeenSet = false;
  bool m_managedInstanceScalingHasBeenSet = false;
  bool m_routingConfigHasBeenSet = false;
  bool m_inferenceAmiVersionHasBeenSet = false;
  bool m_capacityReservationConfigHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SageMaker
}  // namespace Aws