ClusterInstanceGroupSpecification.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/ClusterCapacityRequirements.h>
#include <aws/sagemaker/model/ClusterInstanceRequirements.h>
#include <aws/sagemaker/model/ClusterInstanceStorageConfig.h>
#include <aws/sagemaker/model/ClusterInstanceType.h>
#include <aws/sagemaker/model/ClusterKubernetesConfig.h>
#include <aws/sagemaker/model/ClusterLifeCycleConfig.h>
#include <aws/sagemaker/model/ClusterSlurmConfig.h>
#include <aws/sagemaker/model/DeepHealthCheckType.h>
#include <aws/sagemaker/model/ScheduledUpdateConfig.h>
#include <aws/sagemaker/model/VpcConfig.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace SageMaker {
namespace Model {
 
class ClusterInstanceGroupSpecification {
 public:
  AWS_SAGEMAKER_API ClusterInstanceGroupSpecification() = default;
  AWS_SAGEMAKER_API ClusterInstanceGroupSpecification(Aws::Utils::Json::JsonView jsonValue);
  AWS_SAGEMAKER_API ClusterInstanceGroupSpecification& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_SAGEMAKER_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline int GetInstanceCount() const { return m_instanceCount; }
  inline bool InstanceCountHasBeenSet() const { return m_instanceCountHasBeenSet; }
  inline void SetInstanceCount(int value) {
    m_instanceCountHasBeenSet = true;
    m_instanceCount = value;
  }
  inline ClusterInstanceGroupSpecification& WithInstanceCount(int value) {
    SetInstanceCount(value);
    return *this;
  }
 
 
  inline int GetMinInstanceCount() const { return m_minInstanceCount; }
  inline bool MinInstanceCountHasBeenSet() const { return m_minInstanceCountHasBeenSet; }
  inline void SetMinInstanceCount(int value) {
    m_minInstanceCountHasBeenSet = true;
    m_minInstanceCount = value;
  }
  inline ClusterInstanceGroupSpecification& WithMinInstanceCount(int value) {
    SetMinInstanceCount(value);
    return *this;
  }
 
 
  inline const Aws::String& GetInstanceGroupName() const { return m_instanceGroupName; }
  inline bool InstanceGroupNameHasBeenSet() const { return m_instanceGroupNameHasBeenSet; }
  template <typename InstanceGroupNameT = Aws::String>
  void SetInstanceGroupName(InstanceGroupNameT&& value) {
    m_instanceGroupNameHasBeenSet = true;
    m_instanceGroupName = std::forward<InstanceGroupNameT>(value);
  }
  template <typename InstanceGroupNameT = Aws::String>
  ClusterInstanceGroupSpecification& WithInstanceGroupName(InstanceGroupNameT&& value) {
    SetInstanceGroupName(std::forward<InstanceGroupNameT>(value));
    return *this;
  }
 
 
  inline ClusterInstanceType GetInstanceType() const { return m_instanceType; }
  inline bool InstanceTypeHasBeenSet() const { return m_instanceTypeHasBeenSet; }
  inline void SetInstanceType(ClusterInstanceType value) {
    m_instanceTypeHasBeenSet = true;
    m_instanceType = value;
  }
  inline ClusterInstanceGroupSpecification& WithInstanceType(ClusterInstanceType value) {
    SetInstanceType(value);
    return *this;
  }
 
 
  inline const ClusterInstanceRequirements& GetInstanceRequirements() const { return m_instanceRequirements; }
  inline bool InstanceRequirementsHasBeenSet() const { return m_instanceRequirementsHasBeenSet; }
  template <typename InstanceRequirementsT = ClusterInstanceRequirements>
  void SetInstanceRequirements(InstanceRequirementsT&& value) {
    m_instanceRequirementsHasBeenSet = true;
    m_instanceRequirements = std::forward<InstanceRequirementsT>(value);
  }
  template <typename InstanceRequirementsT = ClusterInstanceRequirements>
  ClusterInstanceGroupSpecification& WithInstanceRequirements(InstanceRequirementsT&& value) {
    SetInstanceRequirements(std::forward<InstanceRequirementsT>(value));
    return *this;
  }
 
 
  inline const ClusterLifeCycleConfig& GetLifeCycleConfig() const { return m_lifeCycleConfig; }
  inline bool LifeCycleConfigHasBeenSet() const { return m_lifeCycleConfigHasBeenSet; }
  template <typename LifeCycleConfigT = ClusterLifeCycleConfig>
  void SetLifeCycleConfig(LifeCycleConfigT&& value) {
    m_lifeCycleConfigHasBeenSet = true;
    m_lifeCycleConfig = std::forward<LifeCycleConfigT>(value);
  }
  template <typename LifeCycleConfigT = ClusterLifeCycleConfig>
  ClusterInstanceGroupSpecification& WithLifeCycleConfig(LifeCycleConfigT&& value) {
    SetLifeCycleConfig(std::forward<LifeCycleConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExecutionRole() const { return m_executionRole; }
  inline bool ExecutionRoleHasBeenSet() const { return m_executionRoleHasBeenSet; }
  template <typename ExecutionRoleT = Aws::String>
  void SetExecutionRole(ExecutionRoleT&& value) {
    m_executionRoleHasBeenSet = true;
    m_executionRole = std::forward<ExecutionRoleT>(value);
  }
  template <typename ExecutionRoleT = Aws::String>
  ClusterInstanceGroupSpecification& WithExecutionRole(ExecutionRoleT&& value) {
    SetExecutionRole(std::forward<ExecutionRoleT>(value));
    return *this;
  }
 
 
  inline int GetThreadsPerCore() const { return m_threadsPerCore; }
  inline bool ThreadsPerCoreHasBeenSet() const { return m_threadsPerCoreHasBeenSet; }
  inline void SetThreadsPerCore(int value) {
    m_threadsPerCoreHasBeenSet = true;
    m_threadsPerCore = value;
  }
  inline ClusterInstanceGroupSpecification& WithThreadsPerCore(int value) {
    SetThreadsPerCore(value);
    return *this;
  }
 
 
  inline const Aws::Vector<ClusterInstanceStorageConfig>& GetInstanceStorageConfigs() const { return m_instanceStorageConfigs; }
  inline bool InstanceStorageConfigsHasBeenSet() const { return m_instanceStorageConfigsHasBeenSet; }
  template <typename InstanceStorageConfigsT = Aws::Vector<ClusterInstanceStorageConfig>>
  void SetInstanceStorageConfigs(InstanceStorageConfigsT&& value) {
    m_instanceStorageConfigsHasBeenSet = true;
    m_instanceStorageConfigs = std::forward<InstanceStorageConfigsT>(value);
  }
  template <typename InstanceStorageConfigsT = Aws::Vector<ClusterInstanceStorageConfig>>
  ClusterInstanceGroupSpecification& WithInstanceStorageConfigs(InstanceStorageConfigsT&& value) {
    SetInstanceStorageConfigs(std::forward<InstanceStorageConfigsT>(value));
    return *this;
  }
  template <typename InstanceStorageConfigsT = ClusterInstanceStorageConfig>
  ClusterInstanceGroupSpecification& AddInstanceStorageConfigs(InstanceStorageConfigsT&& value) {
    m_instanceStorageConfigsHasBeenSet = true;
    m_instanceStorageConfigs.emplace_back(std::forward<InstanceStorageConfigsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<DeepHealthCheckType>& GetOnStartDeepHealthChecks() const { return m_onStartDeepHealthChecks; }
  inline bool OnStartDeepHealthChecksHasBeenSet() const { return m_onStartDeepHealthChecksHasBeenSet; }
  template <typename OnStartDeepHealthChecksT = Aws::Vector<DeepHealthCheckType>>
  void SetOnStartDeepHealthChecks(OnStartDeepHealthChecksT&& value) {
    m_onStartDeepHealthChecksHasBeenSet = true;
    m_onStartDeepHealthChecks = std::forward<OnStartDeepHealthChecksT>(value);
  }
  template <typename OnStartDeepHealthChecksT = Aws::Vector<DeepHealthCheckType>>
  ClusterInstanceGroupSpecification& WithOnStartDeepHealthChecks(OnStartDeepHealthChecksT&& value) {
    SetOnStartDeepHealthChecks(std::forward<OnStartDeepHealthChecksT>(value));
    return *this;
  }
  inline ClusterInstanceGroupSpecification& AddOnStartDeepHealthChecks(DeepHealthCheckType value) {
    m_onStartDeepHealthChecksHasBeenSet = true;
    m_onStartDeepHealthChecks.push_back(value);
    return *this;
  }
 
 
  inline const Aws::String& GetTrainingPlanArn() const { return m_trainingPlanArn; }
  inline bool TrainingPlanArnHasBeenSet() const { return m_trainingPlanArnHasBeenSet; }
  template <typename TrainingPlanArnT = Aws::String>
  void SetTrainingPlanArn(TrainingPlanArnT&& value) {
    m_trainingPlanArnHasBeenSet = true;
    m_trainingPlanArn = std::forward<TrainingPlanArnT>(value);
  }
  template <typename TrainingPlanArnT = Aws::String>
  ClusterInstanceGroupSpecification& WithTrainingPlanArn(TrainingPlanArnT&& value) {
    SetTrainingPlanArn(std::forward<TrainingPlanArnT>(value));
    return *this;
  }
 
 
  inline const VpcConfig& GetOverrideVpcConfig() const { return m_overrideVpcConfig; }
  inline bool OverrideVpcConfigHasBeenSet() const { return m_overrideVpcConfigHasBeenSet; }
  template <typename OverrideVpcConfigT = VpcConfig>
  void SetOverrideVpcConfig(OverrideVpcConfigT&& value) {
    m_overrideVpcConfigHasBeenSet = true;
    m_overrideVpcConfig = std::forward<OverrideVpcConfigT>(value);
  }
  template <typename OverrideVpcConfigT = VpcConfig>
  ClusterInstanceGroupSpecification& WithOverrideVpcConfig(OverrideVpcConfigT&& value) {
    SetOverrideVpcConfig(std::forward<OverrideVpcConfigT>(value));
    return *this;
  }
 
 
  inline const ScheduledUpdateConfig& GetScheduledUpdateConfig() const { return m_scheduledUpdateConfig; }
  inline bool ScheduledUpdateConfigHasBeenSet() const { return m_scheduledUpdateConfigHasBeenSet; }
  template <typename ScheduledUpdateConfigT = ScheduledUpdateConfig>
  void SetScheduledUpdateConfig(ScheduledUpdateConfigT&& value) {
    m_scheduledUpdateConfigHasBeenSet = true;
    m_scheduledUpdateConfig = std::forward<ScheduledUpdateConfigT>(value);
  }
  template <typename ScheduledUpdateConfigT = ScheduledUpdateConfig>
  ClusterInstanceGroupSpecification& WithScheduledUpdateConfig(ScheduledUpdateConfigT&& value) {
    SetScheduledUpdateConfig(std::forward<ScheduledUpdateConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetImageId() const { return m_imageId; }
  inline bool ImageIdHasBeenSet() const { return m_imageIdHasBeenSet; }
  template <typename ImageIdT = Aws::String>
  void SetImageId(ImageIdT&& value) {
    m_imageIdHasBeenSet = true;
    m_imageId = std::forward<ImageIdT>(value);
  }
  template <typename ImageIdT = Aws::String>
  ClusterInstanceGroupSpecification& WithImageId(ImageIdT&& value) {
    SetImageId(std::forward<ImageIdT>(value));
    return *this;
  }
 
 
  inline const ClusterKubernetesConfig& GetKubernetesConfig() const { return m_kubernetesConfig; }
  inline bool KubernetesConfigHasBeenSet() const { return m_kubernetesConfigHasBeenSet; }
  template <typename KubernetesConfigT = ClusterKubernetesConfig>
  void SetKubernetesConfig(KubernetesConfigT&& value) {
    m_kubernetesConfigHasBeenSet = true;
    m_kubernetesConfig = std::forward<KubernetesConfigT>(value);
  }
  template <typename KubernetesConfigT = ClusterKubernetesConfig>
  ClusterInstanceGroupSpecification& WithKubernetesConfig(KubernetesConfigT&& value) {
    SetKubernetesConfig(std::forward<KubernetesConfigT>(value));
    return *this;
  }
 
 
  inline const ClusterSlurmConfig& GetSlurmConfig() const { return m_slurmConfig; }
  inline bool SlurmConfigHasBeenSet() const { return m_slurmConfigHasBeenSet; }
  template <typename SlurmConfigT = ClusterSlurmConfig>
  void SetSlurmConfig(SlurmConfigT&& value) {
    m_slurmConfigHasBeenSet = true;
    m_slurmConfig = std::forward<SlurmConfigT>(value);
  }
  template <typename SlurmConfigT = ClusterSlurmConfig>
  ClusterInstanceGroupSpecification& WithSlurmConfig(SlurmConfigT&& value) {
    SetSlurmConfig(std::forward<SlurmConfigT>(value));
    return *this;
  }
 
 
  inline const ClusterCapacityRequirements& GetCapacityRequirements() const { return m_capacityRequirements; }
  inline bool CapacityRequirementsHasBeenSet() const { return m_capacityRequirementsHasBeenSet; }
  template <typename CapacityRequirementsT = ClusterCapacityRequirements>
  void SetCapacityRequirements(CapacityRequirementsT&& value) {
    m_capacityRequirementsHasBeenSet = true;
    m_capacityRequirements = std::forward<CapacityRequirementsT>(value);
  }
  template <typename CapacityRequirementsT = ClusterCapacityRequirements>
  ClusterInstanceGroupSpecification& WithCapacityRequirements(CapacityRequirementsT&& value) {
    SetCapacityRequirements(std::forward<CapacityRequirementsT>(value));
    return *this;
  }
 private:
  int m_instanceCount{0};
 
  int m_minInstanceCount{0};
 
  Aws::String m_instanceGroupName;
 
  ClusterInstanceType m_instanceType{ClusterInstanceType::NOT_SET};
 
  ClusterInstanceRequirements m_instanceRequirements;
 
  ClusterLifeCycleConfig m_lifeCycleConfig;
 
  Aws::String m_executionRole;
 
  int m_threadsPerCore{0};
 
  Aws::Vector<ClusterInstanceStorageConfig> m_instanceStorageConfigs;
 
  Aws::Vector<DeepHealthCheckType> m_onStartDeepHealthChecks;
 
  Aws::String m_trainingPlanArn;
 
  VpcConfig m_overrideVpcConfig;
 
  ScheduledUpdateConfig m_scheduledUpdateConfig;
 
  Aws::String m_imageId;
 
  ClusterKubernetesConfig m_kubernetesConfig;
 
  ClusterSlurmConfig m_slurmConfig;
 
  ClusterCapacityRequirements m_capacityRequirements;
  bool m_instanceCountHasBeenSet = false;
  bool m_minInstanceCountHasBeenSet = false;
  bool m_instanceGroupNameHasBeenSet = false;
  bool m_instanceTypeHasBeenSet = false;
  bool m_instanceRequirementsHasBeenSet = false;
  bool m_lifeCycleConfigHasBeenSet = false;
  bool m_executionRoleHasBeenSet = false;
  bool m_threadsPerCoreHasBeenSet = false;
  bool m_instanceStorageConfigsHasBeenSet = false;
  bool m_onStartDeepHealthChecksHasBeenSet = false;
  bool m_trainingPlanArnHasBeenSet = false;
  bool m_overrideVpcConfigHasBeenSet = false;
  bool m_scheduledUpdateConfigHasBeenSet = false;
  bool m_imageIdHasBeenSet = false;
  bool m_kubernetesConfigHasBeenSet = false;
  bool m_slurmConfigHasBeenSet = false;
  bool m_capacityRequirementsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SageMaker
}  // namespace Aws