{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.Batch.Types.ComputeResource
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.Batch.Types.ComputeResource where

import Amazonka.Batch.Types.CRAllocationStrategy
import Amazonka.Batch.Types.CRType
import Amazonka.Batch.Types.Ec2Configuration
import Amazonka.Batch.Types.LaunchTemplateSpecification
import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude

-- | An object representing an Batch compute resource. For more information,
-- see
-- <https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html Compute Environments>
-- in the /Batch User Guide/.
--
-- /See:/ 'newComputeResource' smart constructor.
data ComputeResource = ComputeResource'
  { -- | The Amazon EC2 security groups associated with instances launched in the
    -- compute environment. One or more security groups must be specified,
    -- either in @securityGroupIds@ or using a launch template referenced in
    -- @launchTemplate@. This parameter is required for jobs that are running
    -- on Fargate resources and must contain at least one security group.
    -- Fargate doesn\'t support launch templates. If security groups are
    -- specified using both @securityGroupIds@ and @launchTemplate@, the values
    -- in @securityGroupIds@ are used.
    ComputeResource -> Maybe [Text]
securityGroupIds :: Prelude.Maybe [Prelude.Text],
    -- | The instances types that can be launched. You can specify instance
    -- families to launch any instance type within those families (for example,
    -- @c5@ or @p3@), or you can specify specific sizes within a family (such
    -- as @c5.8xlarge@). You can also choose @optimal@ to select instance types
    -- (from the C4, M4, and R4 instance families) that match the demand of
    -- your job queues.
    --
    -- This parameter isn\'t applicable to jobs that are running on Fargate
    -- resources, and shouldn\'t be specified.
    --
    -- When you create a compute environment, the instance types that you
    -- select for the compute environment must share the same architecture. For
    -- example, you can\'t mix x86 and ARM instances in the same compute
    -- environment.
    --
    -- Currently, @optimal@ uses instance types from the C4, M4, and R4
    -- instance families. In Regions that don\'t have instance types from those
    -- instance families, instance types from the C5, M5. and R5 instance
    -- families are used.
    ComputeResource -> Maybe [Text]
instanceTypes :: Prelude.Maybe [Prelude.Text],
    -- | The Amazon ECS instance profile applied to Amazon EC2 instances in a
    -- compute environment. You can specify the short name or full Amazon
    -- Resource Name (ARN) of an instance profile. For example,
    -- @ ecsInstanceRole @ or
    -- @arn:aws:iam::\<aws_account_id>:instance-profile\/ecsInstanceRole @. For
    -- more information, see
    -- <https://docs.aws.amazon.com/batch/latest/userguide/instance_IAM_role.html Amazon ECS Instance Role>
    -- in the /Batch User Guide/.
    --
    -- This parameter isn\'t applicable to jobs that are running on Fargate
    -- resources, and shouldn\'t be specified.
    ComputeResource -> Maybe Text
instanceRole :: Prelude.Maybe Prelude.Text,
    -- | The Amazon EC2 key pair that\'s used for instances launched in the
    -- compute environment. You can use this key pair to log in to your
    -- instances with SSH.
    --
    -- This parameter isn\'t applicable to jobs that are running on Fargate
    -- resources, and shouldn\'t be specified.
    ComputeResource -> Maybe Text
ec2KeyPair :: Prelude.Maybe Prelude.Text,
    -- | The minimum number of Amazon EC2 vCPUs that an environment should
    -- maintain (even if the compute environment is @DISABLED@).
    --
    -- This parameter isn\'t applicable to jobs that are running on Fargate
    -- resources, and shouldn\'t be specified.
    ComputeResource -> Maybe Int
minvCpus :: Prelude.Maybe Prelude.Int,
    -- | Provides information used to select Amazon Machine Images (AMIs) for EC2
    -- instances in the compute environment. If @Ec2Configuration@ isn\'t
    -- specified, the default is @ECS_AL1@.
    --
    -- This parameter isn\'t applicable to jobs that are running on Fargate
    -- resources, and shouldn\'t be specified.
    ComputeResource -> Maybe [Ec2Configuration]
ec2Configuration :: Prelude.Maybe [Ec2Configuration],
    -- | The maximum percentage that a Spot Instance price can be when compared
    -- with the On-Demand price for that instance type before instances are
    -- launched. For example, if your maximum percentage is 20%, then the Spot
    -- price must be less than 20% of the current On-Demand price for that
    -- Amazon EC2 instance. You always pay the lowest (market) price and never
    -- more than your maximum percentage. If you leave this field empty, the
    -- default value is 100% of the On-Demand price.
    --
    -- This parameter isn\'t applicable to jobs that are running on Fargate
    -- resources, and shouldn\'t be specified.
    ComputeResource -> Maybe Int
bidPercentage :: Prelude.Maybe Prelude.Int,
    -- | The Amazon Resource Name (ARN) of the Amazon EC2 Spot Fleet IAM role
    -- applied to a @SPOT@ compute environment. This role is required if the
    -- allocation strategy set to @BEST_FIT@ or if the allocation strategy
    -- isn\'t specified. For more information, see
    -- <https://docs.aws.amazon.com/batch/latest/userguide/spot_fleet_IAM_role.html Amazon EC2 Spot Fleet Role>
    -- in the /Batch User Guide/.
    --
    -- This parameter isn\'t applicable to jobs that are running on Fargate
    -- resources, and shouldn\'t be specified.
    --
    -- To tag your Spot Instances on creation, the Spot Fleet IAM role
    -- specified here must use the newer __AmazonEC2SpotFleetTaggingRole__
    -- managed policy. The previously recommended __AmazonEC2SpotFleetRole__
    -- managed policy doesn\'t have the required permissions to tag Spot
    -- Instances. For more information, see
    -- <https://docs.aws.amazon.com/batch/latest/userguide/troubleshooting.html#spot-instance-no-tag Spot Instances not tagged on creation>
    -- in the /Batch User Guide/.
    ComputeResource -> Maybe Text
spotIamFleetRole :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Machine Image (AMI) ID used for instances launched in the
    -- compute environment. This parameter is overridden by the
    -- @imageIdOverride@ member of the @Ec2Configuration@ structure.
    --
    -- This parameter isn\'t applicable to jobs that are running on Fargate
    -- resources, and shouldn\'t be specified.
    --
    -- The AMI that you choose for a compute environment must match the
    -- architecture of the instance types that you intend to use for that
    -- compute environment. For example, if your compute environment uses A1
    -- instance types, the compute resource AMI that you choose must support
    -- ARM instances. Amazon ECS vends both x86 and ARM versions of the Amazon
    -- ECS-optimized Amazon Linux 2 AMI. For more information, see
    -- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#ecs-optimized-ami-linux-variants.html Amazon ECS-optimized Amazon Linux 2 AMI>
    -- in the /Amazon Elastic Container Service Developer Guide/.
    ComputeResource -> Maybe Text
imageId :: Prelude.Maybe Prelude.Text,
    -- | The launch template to use for your compute resources. Any other compute
    -- resource parameters that you specify in a CreateComputeEnvironment API
    -- operation override the same parameters in the launch template. You must
    -- specify either the launch template ID or launch template name in the
    -- request, but not both. For more information, see
    -- <https://docs.aws.amazon.com/batch/latest/userguide/launch-templates.html Launch Template Support>
    -- in the /Batch User Guide/.
    --
    -- This parameter isn\'t applicable to jobs that are running on Fargate
    -- resources, and shouldn\'t be specified.
    ComputeResource -> Maybe LaunchTemplateSpecification
launchTemplate :: Prelude.Maybe LaunchTemplateSpecification,
    -- | The desired number of Amazon EC2 vCPUS in the compute environment. Batch
    -- modifies this value between the minimum and maximum values, based on job
    -- queue demand.
    --
    -- This parameter isn\'t applicable to jobs that are running on Fargate
    -- resources, and shouldn\'t be specified.
    ComputeResource -> Maybe Int
desiredvCpus :: Prelude.Maybe Prelude.Int,
    -- | The allocation strategy to use for the compute resource if not enough
    -- instances of the best fitting instance type can be allocated. This might
    -- be because of availability of the instance type in the Region or
    -- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-resource-limits.html Amazon EC2 service limits>.
    -- For more information, see
    -- <https://docs.aws.amazon.com/batch/latest/userguide/allocation-strategies.html Allocation Strategies>
    -- in the /Batch User Guide/.
    --
    -- This parameter isn\'t applicable to jobs that are running on Fargate
    -- resources, and shouldn\'t be specified.
    --
    -- [BEST_FIT (default)]
    --     Batch selects an instance type that best fits the needs of the jobs
    --     with a preference for the lowest-cost instance type. If additional
    --     instances of the selected instance type aren\'t available, Batch
    --     waits for the additional instances to be available. If there aren\'t
    --     enough instances available, or if the user is reaching
    --     <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-resource-limits.html Amazon EC2 service limits>
    --     then additional jobs aren\'t run until the currently running jobs
    --     have completed. This allocation strategy keeps costs lower but can
    --     limit scaling. If you are using Spot Fleets with @BEST_FIT@ then the
    --     Spot Fleet IAM Role must be specified.
    --
    -- [BEST_FIT_PROGRESSIVE]
    --     Batch will select additional instance types that are large enough to
    --     meet the requirements of the jobs in the queue, with a preference
    --     for instance types with a lower cost per unit vCPU. If additional
    --     instances of the previously selected instance types aren\'t
    --     available, Batch will select new instance types.
    --
    -- [SPOT_CAPACITY_OPTIMIZED]
    --     Batch will select one or more instance types that are large enough
    --     to meet the requirements of the jobs in the queue, with a preference
    --     for instance types that are less likely to be interrupted. This
    --     allocation strategy is only available for Spot Instance compute
    --     resources.
    --
    -- With both @BEST_FIT_PROGRESSIVE@ and @SPOT_CAPACITY_OPTIMIZED@
    -- strategies, Batch might need to go above @maxvCpus@ to meet your
    -- capacity requirements. In this event, Batch never exceeds @maxvCpus@ by
    -- more than a single instance.
    ComputeResource -> Maybe CRAllocationStrategy
allocationStrategy :: Prelude.Maybe CRAllocationStrategy,
    -- | The Amazon EC2 placement group to associate with your compute resources.
    -- If you intend to submit multi-node parallel jobs to your compute
    -- environment, you should consider creating a cluster placement group and
    -- associate it with your compute resources. This keeps your multi-node
    -- parallel job on a logical grouping of instances within a single
    -- Availability Zone with high network flow potential. For more
    -- information, see
    -- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html Placement Groups>
    -- in the /Amazon EC2 User Guide for Linux Instances/.
    --
    -- This parameter isn\'t applicable to jobs that are running on Fargate
    -- resources, and shouldn\'t be specified.
    ComputeResource -> Maybe Text
placementGroup :: Prelude.Maybe Prelude.Text,
    -- | Key-value pair tags to be applied to EC2 resources that are launched in
    -- the compute environment. For Batch, these take the form of \"String1\":
    -- \"String2\", where String1 is the tag key and String2 is the tag
    -- value−for example, @{ \"Name\": \"Batch Instance - C4OnDemand\" }@. This
    -- is helpful for recognizing your Batch instances in the Amazon EC2
    -- console. These tags can\'t be updated or removed after the compute
    -- environment is created.Aany changes to these tags require that you
    -- create a new compute environment and remove the old compute environment.
    -- These tags aren\'t seen when using the Batch @ListTagsForResource@ API
    -- operation.
    --
    -- This parameter isn\'t applicable to jobs that are running on Fargate
    -- resources, and shouldn\'t be specified.
    ComputeResource -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The type of compute environment: @EC2@, @SPOT@, @FARGATE@, or
    -- @FARGATE_SPOT@. For more information, see
    -- <https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html Compute Environments>
    -- in the /Batch User Guide/.
    --
    -- If you choose @SPOT@, you must also specify an Amazon EC2 Spot Fleet
    -- role with the @spotIamFleetRole@ parameter. For more information, see
    -- <https://docs.aws.amazon.com/batch/latest/userguide/spot_fleet_IAM_role.html Amazon EC2 Spot Fleet role>
    -- in the /Batch User Guide/.
    ComputeResource -> CRType
type' :: CRType,
    -- | The maximum number of Amazon EC2 vCPUs that a compute environment can
    -- reach.
    --
    -- With both @BEST_FIT_PROGRESSIVE@ and @SPOT_CAPACITY_OPTIMIZED@
    -- allocation strategies, Batch might need to exceed @maxvCpus@ to meet
    -- your capacity requirements. In this event, Batch never exceeds
    -- @maxvCpus@ by more than a single instance. For example, no more than a
    -- single instance from among those specified in your compute environment
    -- is allocated.
    ComputeResource -> Int
maxvCpus :: Prelude.Int,
    -- | The VPC subnets where the compute resources are launched. These subnets
    -- must be within the same VPC. Fargate compute resources can contain up to
    -- 16 subnets. For more information, see
    -- <https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html VPCs and Subnets>
    -- in the /Amazon VPC User Guide/.
    ComputeResource -> [Text]
subnets :: [Prelude.Text]
  }
  deriving (ComputeResource -> ComputeResource -> Bool
(ComputeResource -> ComputeResource -> Bool)
-> (ComputeResource -> ComputeResource -> Bool)
-> Eq ComputeResource
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ComputeResource -> ComputeResource -> Bool
$c/= :: ComputeResource -> ComputeResource -> Bool
== :: ComputeResource -> ComputeResource -> Bool
$c== :: ComputeResource -> ComputeResource -> Bool
Prelude.Eq, ReadPrec [ComputeResource]
ReadPrec ComputeResource
Int -> ReadS ComputeResource
ReadS [ComputeResource]
(Int -> ReadS ComputeResource)
-> ReadS [ComputeResource]
-> ReadPrec ComputeResource
-> ReadPrec [ComputeResource]
-> Read ComputeResource
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ComputeResource]
$creadListPrec :: ReadPrec [ComputeResource]
readPrec :: ReadPrec ComputeResource
$creadPrec :: ReadPrec ComputeResource
readList :: ReadS [ComputeResource]
$creadList :: ReadS [ComputeResource]
readsPrec :: Int -> ReadS ComputeResource
$creadsPrec :: Int -> ReadS ComputeResource
Prelude.Read, Int -> ComputeResource -> ShowS
[ComputeResource] -> ShowS
ComputeResource -> String
(Int -> ComputeResource -> ShowS)
-> (ComputeResource -> String)
-> ([ComputeResource] -> ShowS)
-> Show ComputeResource
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ComputeResource] -> ShowS
$cshowList :: [ComputeResource] -> ShowS
show :: ComputeResource -> String
$cshow :: ComputeResource -> String
showsPrec :: Int -> ComputeResource -> ShowS
$cshowsPrec :: Int -> ComputeResource -> ShowS
Prelude.Show, (forall x. ComputeResource -> Rep ComputeResource x)
-> (forall x. Rep ComputeResource x -> ComputeResource)
-> Generic ComputeResource
forall x. Rep ComputeResource x -> ComputeResource
forall x. ComputeResource -> Rep ComputeResource x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ComputeResource x -> ComputeResource
$cfrom :: forall x. ComputeResource -> Rep ComputeResource x
Prelude.Generic)

-- |
-- Create a value of 'ComputeResource' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'securityGroupIds', 'computeResource_securityGroupIds' - The Amazon EC2 security groups associated with instances launched in the
-- compute environment. One or more security groups must be specified,
-- either in @securityGroupIds@ or using a launch template referenced in
-- @launchTemplate@. This parameter is required for jobs that are running
-- on Fargate resources and must contain at least one security group.
-- Fargate doesn\'t support launch templates. If security groups are
-- specified using both @securityGroupIds@ and @launchTemplate@, the values
-- in @securityGroupIds@ are used.
--
-- 'instanceTypes', 'computeResource_instanceTypes' - The instances types that can be launched. You can specify instance
-- families to launch any instance type within those families (for example,
-- @c5@ or @p3@), or you can specify specific sizes within a family (such
-- as @c5.8xlarge@). You can also choose @optimal@ to select instance types
-- (from the C4, M4, and R4 instance families) that match the demand of
-- your job queues.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- When you create a compute environment, the instance types that you
-- select for the compute environment must share the same architecture. For
-- example, you can\'t mix x86 and ARM instances in the same compute
-- environment.
--
-- Currently, @optimal@ uses instance types from the C4, M4, and R4
-- instance families. In Regions that don\'t have instance types from those
-- instance families, instance types from the C5, M5. and R5 instance
-- families are used.
--
-- 'instanceRole', 'computeResource_instanceRole' - The Amazon ECS instance profile applied to Amazon EC2 instances in a
-- compute environment. You can specify the short name or full Amazon
-- Resource Name (ARN) of an instance profile. For example,
-- @ ecsInstanceRole @ or
-- @arn:aws:iam::\<aws_account_id>:instance-profile\/ecsInstanceRole @. For
-- more information, see
-- <https://docs.aws.amazon.com/batch/latest/userguide/instance_IAM_role.html Amazon ECS Instance Role>
-- in the /Batch User Guide/.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- 'ec2KeyPair', 'computeResource_ec2KeyPair' - The Amazon EC2 key pair that\'s used for instances launched in the
-- compute environment. You can use this key pair to log in to your
-- instances with SSH.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- 'minvCpus', 'computeResource_minvCpus' - The minimum number of Amazon EC2 vCPUs that an environment should
-- maintain (even if the compute environment is @DISABLED@).
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- 'ec2Configuration', 'computeResource_ec2Configuration' - Provides information used to select Amazon Machine Images (AMIs) for EC2
-- instances in the compute environment. If @Ec2Configuration@ isn\'t
-- specified, the default is @ECS_AL1@.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- 'bidPercentage', 'computeResource_bidPercentage' - The maximum percentage that a Spot Instance price can be when compared
-- with the On-Demand price for that instance type before instances are
-- launched. For example, if your maximum percentage is 20%, then the Spot
-- price must be less than 20% of the current On-Demand price for that
-- Amazon EC2 instance. You always pay the lowest (market) price and never
-- more than your maximum percentage. If you leave this field empty, the
-- default value is 100% of the On-Demand price.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- 'spotIamFleetRole', 'computeResource_spotIamFleetRole' - The Amazon Resource Name (ARN) of the Amazon EC2 Spot Fleet IAM role
-- applied to a @SPOT@ compute environment. This role is required if the
-- allocation strategy set to @BEST_FIT@ or if the allocation strategy
-- isn\'t specified. For more information, see
-- <https://docs.aws.amazon.com/batch/latest/userguide/spot_fleet_IAM_role.html Amazon EC2 Spot Fleet Role>
-- in the /Batch User Guide/.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- To tag your Spot Instances on creation, the Spot Fleet IAM role
-- specified here must use the newer __AmazonEC2SpotFleetTaggingRole__
-- managed policy. The previously recommended __AmazonEC2SpotFleetRole__
-- managed policy doesn\'t have the required permissions to tag Spot
-- Instances. For more information, see
-- <https://docs.aws.amazon.com/batch/latest/userguide/troubleshooting.html#spot-instance-no-tag Spot Instances not tagged on creation>
-- in the /Batch User Guide/.
--
-- 'imageId', 'computeResource_imageId' - The Amazon Machine Image (AMI) ID used for instances launched in the
-- compute environment. This parameter is overridden by the
-- @imageIdOverride@ member of the @Ec2Configuration@ structure.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- The AMI that you choose for a compute environment must match the
-- architecture of the instance types that you intend to use for that
-- compute environment. For example, if your compute environment uses A1
-- instance types, the compute resource AMI that you choose must support
-- ARM instances. Amazon ECS vends both x86 and ARM versions of the Amazon
-- ECS-optimized Amazon Linux 2 AMI. For more information, see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#ecs-optimized-ami-linux-variants.html Amazon ECS-optimized Amazon Linux 2 AMI>
-- in the /Amazon Elastic Container Service Developer Guide/.
--
-- 'launchTemplate', 'computeResource_launchTemplate' - The launch template to use for your compute resources. Any other compute
-- resource parameters that you specify in a CreateComputeEnvironment API
-- operation override the same parameters in the launch template. You must
-- specify either the launch template ID or launch template name in the
-- request, but not both. For more information, see
-- <https://docs.aws.amazon.com/batch/latest/userguide/launch-templates.html Launch Template Support>
-- in the /Batch User Guide/.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- 'desiredvCpus', 'computeResource_desiredvCpus' - The desired number of Amazon EC2 vCPUS in the compute environment. Batch
-- modifies this value between the minimum and maximum values, based on job
-- queue demand.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- 'allocationStrategy', 'computeResource_allocationStrategy' - The allocation strategy to use for the compute resource if not enough
-- instances of the best fitting instance type can be allocated. This might
-- be because of availability of the instance type in the Region or
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-resource-limits.html Amazon EC2 service limits>.
-- For more information, see
-- <https://docs.aws.amazon.com/batch/latest/userguide/allocation-strategies.html Allocation Strategies>
-- in the /Batch User Guide/.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- [BEST_FIT (default)]
--     Batch selects an instance type that best fits the needs of the jobs
--     with a preference for the lowest-cost instance type. If additional
--     instances of the selected instance type aren\'t available, Batch
--     waits for the additional instances to be available. If there aren\'t
--     enough instances available, or if the user is reaching
--     <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-resource-limits.html Amazon EC2 service limits>
--     then additional jobs aren\'t run until the currently running jobs
--     have completed. This allocation strategy keeps costs lower but can
--     limit scaling. If you are using Spot Fleets with @BEST_FIT@ then the
--     Spot Fleet IAM Role must be specified.
--
-- [BEST_FIT_PROGRESSIVE]
--     Batch will select additional instance types that are large enough to
--     meet the requirements of the jobs in the queue, with a preference
--     for instance types with a lower cost per unit vCPU. If additional
--     instances of the previously selected instance types aren\'t
--     available, Batch will select new instance types.
--
-- [SPOT_CAPACITY_OPTIMIZED]
--     Batch will select one or more instance types that are large enough
--     to meet the requirements of the jobs in the queue, with a preference
--     for instance types that are less likely to be interrupted. This
--     allocation strategy is only available for Spot Instance compute
--     resources.
--
-- With both @BEST_FIT_PROGRESSIVE@ and @SPOT_CAPACITY_OPTIMIZED@
-- strategies, Batch might need to go above @maxvCpus@ to meet your
-- capacity requirements. In this event, Batch never exceeds @maxvCpus@ by
-- more than a single instance.
--
-- 'placementGroup', 'computeResource_placementGroup' - The Amazon EC2 placement group to associate with your compute resources.
-- If you intend to submit multi-node parallel jobs to your compute
-- environment, you should consider creating a cluster placement group and
-- associate it with your compute resources. This keeps your multi-node
-- parallel job on a logical grouping of instances within a single
-- Availability Zone with high network flow potential. For more
-- information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html Placement Groups>
-- in the /Amazon EC2 User Guide for Linux Instances/.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- 'tags', 'computeResource_tags' - Key-value pair tags to be applied to EC2 resources that are launched in
-- the compute environment. For Batch, these take the form of \"String1\":
-- \"String2\", where String1 is the tag key and String2 is the tag
-- value−for example, @{ \"Name\": \"Batch Instance - C4OnDemand\" }@. This
-- is helpful for recognizing your Batch instances in the Amazon EC2
-- console. These tags can\'t be updated or removed after the compute
-- environment is created.Aany changes to these tags require that you
-- create a new compute environment and remove the old compute environment.
-- These tags aren\'t seen when using the Batch @ListTagsForResource@ API
-- operation.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- 'type'', 'computeResource_type' - The type of compute environment: @EC2@, @SPOT@, @FARGATE@, or
-- @FARGATE_SPOT@. For more information, see
-- <https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html Compute Environments>
-- in the /Batch User Guide/.
--
-- If you choose @SPOT@, you must also specify an Amazon EC2 Spot Fleet
-- role with the @spotIamFleetRole@ parameter. For more information, see
-- <https://docs.aws.amazon.com/batch/latest/userguide/spot_fleet_IAM_role.html Amazon EC2 Spot Fleet role>
-- in the /Batch User Guide/.
--
-- 'maxvCpus', 'computeResource_maxvCpus' - The maximum number of Amazon EC2 vCPUs that a compute environment can
-- reach.
--
-- With both @BEST_FIT_PROGRESSIVE@ and @SPOT_CAPACITY_OPTIMIZED@
-- allocation strategies, Batch might need to exceed @maxvCpus@ to meet
-- your capacity requirements. In this event, Batch never exceeds
-- @maxvCpus@ by more than a single instance. For example, no more than a
-- single instance from among those specified in your compute environment
-- is allocated.
--
-- 'subnets', 'computeResource_subnets' - The VPC subnets where the compute resources are launched. These subnets
-- must be within the same VPC. Fargate compute resources can contain up to
-- 16 subnets. For more information, see
-- <https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html VPCs and Subnets>
-- in the /Amazon VPC User Guide/.
newComputeResource ::
  -- | 'type''
  CRType ->
  -- | 'maxvCpus'
  Prelude.Int ->
  ComputeResource
newComputeResource :: CRType -> Int -> ComputeResource
newComputeResource CRType
pType_ Int
pMaxvCpus_ =
  ComputeResource' :: Maybe [Text]
-> Maybe [Text]
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe [Ec2Configuration]
-> Maybe Int
-> Maybe Text
-> Maybe Text
-> Maybe LaunchTemplateSpecification
-> Maybe Int
-> Maybe CRAllocationStrategy
-> Maybe Text
-> Maybe (HashMap Text Text)
-> CRType
-> Int
-> [Text]
-> ComputeResource
ComputeResource'
    { $sel:securityGroupIds:ComputeResource' :: Maybe [Text]
securityGroupIds =
        Maybe [Text]
forall a. Maybe a
Prelude.Nothing,
      $sel:instanceTypes:ComputeResource' :: Maybe [Text]
instanceTypes = Maybe [Text]
forall a. Maybe a
Prelude.Nothing,
      $sel:instanceRole:ComputeResource' :: Maybe Text
instanceRole = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:ec2KeyPair:ComputeResource' :: Maybe Text
ec2KeyPair = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:minvCpus:ComputeResource' :: Maybe Int
minvCpus = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:ec2Configuration:ComputeResource' :: Maybe [Ec2Configuration]
ec2Configuration = Maybe [Ec2Configuration]
forall a. Maybe a
Prelude.Nothing,
      $sel:bidPercentage:ComputeResource' :: Maybe Int
bidPercentage = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:spotIamFleetRole:ComputeResource' :: Maybe Text
spotIamFleetRole = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:imageId:ComputeResource' :: Maybe Text
imageId = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:launchTemplate:ComputeResource' :: Maybe LaunchTemplateSpecification
launchTemplate = Maybe LaunchTemplateSpecification
forall a. Maybe a
Prelude.Nothing,
      $sel:desiredvCpus:ComputeResource' :: Maybe Int
desiredvCpus = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:allocationStrategy:ComputeResource' :: Maybe CRAllocationStrategy
allocationStrategy = Maybe CRAllocationStrategy
forall a. Maybe a
Prelude.Nothing,
      $sel:placementGroup:ComputeResource' :: Maybe Text
placementGroup = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:tags:ComputeResource' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
forall a. Maybe a
Prelude.Nothing,
      $sel:type':ComputeResource' :: CRType
type' = CRType
pType_,
      $sel:maxvCpus:ComputeResource' :: Int
maxvCpus = Int
pMaxvCpus_,
      $sel:subnets:ComputeResource' :: [Text]
subnets = [Text]
forall a. Monoid a => a
Prelude.mempty
    }

-- | The Amazon EC2 security groups associated with instances launched in the
-- compute environment. One or more security groups must be specified,
-- either in @securityGroupIds@ or using a launch template referenced in
-- @launchTemplate@. This parameter is required for jobs that are running
-- on Fargate resources and must contain at least one security group.
-- Fargate doesn\'t support launch templates. If security groups are
-- specified using both @securityGroupIds@ and @launchTemplate@, the values
-- in @securityGroupIds@ are used.
computeResource_securityGroupIds :: Lens.Lens' ComputeResource (Prelude.Maybe [Prelude.Text])
computeResource_securityGroupIds :: (Maybe [Text] -> f (Maybe [Text]))
-> ComputeResource -> f ComputeResource
computeResource_securityGroupIds = (ComputeResource -> Maybe [Text])
-> (ComputeResource -> Maybe [Text] -> ComputeResource)
-> Lens
     ComputeResource ComputeResource (Maybe [Text]) (Maybe [Text])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {Maybe [Text]
securityGroupIds :: Maybe [Text]
$sel:securityGroupIds:ComputeResource' :: ComputeResource -> Maybe [Text]
securityGroupIds} -> Maybe [Text]
securityGroupIds) (\s :: ComputeResource
s@ComputeResource' {} Maybe [Text]
a -> ComputeResource
s {$sel:securityGroupIds:ComputeResource' :: Maybe [Text]
securityGroupIds = Maybe [Text]
a} :: ComputeResource) ((Maybe [Text] -> f (Maybe [Text]))
 -> ComputeResource -> f ComputeResource)
-> ((Maybe [Text] -> f (Maybe [Text]))
    -> Maybe [Text] -> f (Maybe [Text]))
-> (Maybe [Text] -> f (Maybe [Text]))
-> ComputeResource
-> f ComputeResource
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Text] [Text] [Text] [Text]
-> Iso (Maybe [Text]) (Maybe [Text]) (Maybe [Text]) (Maybe [Text])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [Text] [Text] [Text] [Text]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The instances types that can be launched. You can specify instance
-- families to launch any instance type within those families (for example,
-- @c5@ or @p3@), or you can specify specific sizes within a family (such
-- as @c5.8xlarge@). You can also choose @optimal@ to select instance types
-- (from the C4, M4, and R4 instance families) that match the demand of
-- your job queues.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- When you create a compute environment, the instance types that you
-- select for the compute environment must share the same architecture. For
-- example, you can\'t mix x86 and ARM instances in the same compute
-- environment.
--
-- Currently, @optimal@ uses instance types from the C4, M4, and R4
-- instance families. In Regions that don\'t have instance types from those
-- instance families, instance types from the C5, M5. and R5 instance
-- families are used.
computeResource_instanceTypes :: Lens.Lens' ComputeResource (Prelude.Maybe [Prelude.Text])
computeResource_instanceTypes :: (Maybe [Text] -> f (Maybe [Text]))
-> ComputeResource -> f ComputeResource
computeResource_instanceTypes = (ComputeResource -> Maybe [Text])
-> (ComputeResource -> Maybe [Text] -> ComputeResource)
-> Lens
     ComputeResource ComputeResource (Maybe [Text]) (Maybe [Text])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {Maybe [Text]
instanceTypes :: Maybe [Text]
$sel:instanceTypes:ComputeResource' :: ComputeResource -> Maybe [Text]
instanceTypes} -> Maybe [Text]
instanceTypes) (\s :: ComputeResource
s@ComputeResource' {} Maybe [Text]
a -> ComputeResource
s {$sel:instanceTypes:ComputeResource' :: Maybe [Text]
instanceTypes = Maybe [Text]
a} :: ComputeResource) ((Maybe [Text] -> f (Maybe [Text]))
 -> ComputeResource -> f ComputeResource)
-> ((Maybe [Text] -> f (Maybe [Text]))
    -> Maybe [Text] -> f (Maybe [Text]))
-> (Maybe [Text] -> f (Maybe [Text]))
-> ComputeResource
-> f ComputeResource
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Text] [Text] [Text] [Text]
-> Iso (Maybe [Text]) (Maybe [Text]) (Maybe [Text]) (Maybe [Text])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [Text] [Text] [Text] [Text]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The Amazon ECS instance profile applied to Amazon EC2 instances in a
-- compute environment. You can specify the short name or full Amazon
-- Resource Name (ARN) of an instance profile. For example,
-- @ ecsInstanceRole @ or
-- @arn:aws:iam::\<aws_account_id>:instance-profile\/ecsInstanceRole @. For
-- more information, see
-- <https://docs.aws.amazon.com/batch/latest/userguide/instance_IAM_role.html Amazon ECS Instance Role>
-- in the /Batch User Guide/.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
computeResource_instanceRole :: Lens.Lens' ComputeResource (Prelude.Maybe Prelude.Text)
computeResource_instanceRole :: (Maybe Text -> f (Maybe Text))
-> ComputeResource -> f ComputeResource
computeResource_instanceRole = (ComputeResource -> Maybe Text)
-> (ComputeResource -> Maybe Text -> ComputeResource)
-> Lens ComputeResource ComputeResource (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {Maybe Text
instanceRole :: Maybe Text
$sel:instanceRole:ComputeResource' :: ComputeResource -> Maybe Text
instanceRole} -> Maybe Text
instanceRole) (\s :: ComputeResource
s@ComputeResource' {} Maybe Text
a -> ComputeResource
s {$sel:instanceRole:ComputeResource' :: Maybe Text
instanceRole = Maybe Text
a} :: ComputeResource)

-- | The Amazon EC2 key pair that\'s used for instances launched in the
-- compute environment. You can use this key pair to log in to your
-- instances with SSH.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
computeResource_ec2KeyPair :: Lens.Lens' ComputeResource (Prelude.Maybe Prelude.Text)
computeResource_ec2KeyPair :: (Maybe Text -> f (Maybe Text))
-> ComputeResource -> f ComputeResource
computeResource_ec2KeyPair = (ComputeResource -> Maybe Text)
-> (ComputeResource -> Maybe Text -> ComputeResource)
-> Lens ComputeResource ComputeResource (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {Maybe Text
ec2KeyPair :: Maybe Text
$sel:ec2KeyPair:ComputeResource' :: ComputeResource -> Maybe Text
ec2KeyPair} -> Maybe Text
ec2KeyPair) (\s :: ComputeResource
s@ComputeResource' {} Maybe Text
a -> ComputeResource
s {$sel:ec2KeyPair:ComputeResource' :: Maybe Text
ec2KeyPair = Maybe Text
a} :: ComputeResource)

-- | The minimum number of Amazon EC2 vCPUs that an environment should
-- maintain (even if the compute environment is @DISABLED@).
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
computeResource_minvCpus :: Lens.Lens' ComputeResource (Prelude.Maybe Prelude.Int)
computeResource_minvCpus :: (Maybe Int -> f (Maybe Int))
-> ComputeResource -> f ComputeResource
computeResource_minvCpus = (ComputeResource -> Maybe Int)
-> (ComputeResource -> Maybe Int -> ComputeResource)
-> Lens ComputeResource ComputeResource (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {Maybe Int
minvCpus :: Maybe Int
$sel:minvCpus:ComputeResource' :: ComputeResource -> Maybe Int
minvCpus} -> Maybe Int
minvCpus) (\s :: ComputeResource
s@ComputeResource' {} Maybe Int
a -> ComputeResource
s {$sel:minvCpus:ComputeResource' :: Maybe Int
minvCpus = Maybe Int
a} :: ComputeResource)

-- | Provides information used to select Amazon Machine Images (AMIs) for EC2
-- instances in the compute environment. If @Ec2Configuration@ isn\'t
-- specified, the default is @ECS_AL1@.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
computeResource_ec2Configuration :: Lens.Lens' ComputeResource (Prelude.Maybe [Ec2Configuration])
computeResource_ec2Configuration :: (Maybe [Ec2Configuration] -> f (Maybe [Ec2Configuration]))
-> ComputeResource -> f ComputeResource
computeResource_ec2Configuration = (ComputeResource -> Maybe [Ec2Configuration])
-> (ComputeResource -> Maybe [Ec2Configuration] -> ComputeResource)
-> Lens
     ComputeResource
     ComputeResource
     (Maybe [Ec2Configuration])
     (Maybe [Ec2Configuration])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {Maybe [Ec2Configuration]
ec2Configuration :: Maybe [Ec2Configuration]
$sel:ec2Configuration:ComputeResource' :: ComputeResource -> Maybe [Ec2Configuration]
ec2Configuration} -> Maybe [Ec2Configuration]
ec2Configuration) (\s :: ComputeResource
s@ComputeResource' {} Maybe [Ec2Configuration]
a -> ComputeResource
s {$sel:ec2Configuration:ComputeResource' :: Maybe [Ec2Configuration]
ec2Configuration = Maybe [Ec2Configuration]
a} :: ComputeResource) ((Maybe [Ec2Configuration] -> f (Maybe [Ec2Configuration]))
 -> ComputeResource -> f ComputeResource)
-> ((Maybe [Ec2Configuration] -> f (Maybe [Ec2Configuration]))
    -> Maybe [Ec2Configuration] -> f (Maybe [Ec2Configuration]))
-> (Maybe [Ec2Configuration] -> f (Maybe [Ec2Configuration]))
-> ComputeResource
-> f ComputeResource
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [Ec2Configuration]
  [Ec2Configuration]
  [Ec2Configuration]
  [Ec2Configuration]
-> Iso
     (Maybe [Ec2Configuration])
     (Maybe [Ec2Configuration])
     (Maybe [Ec2Configuration])
     (Maybe [Ec2Configuration])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso
  [Ec2Configuration]
  [Ec2Configuration]
  [Ec2Configuration]
  [Ec2Configuration]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The maximum percentage that a Spot Instance price can be when compared
-- with the On-Demand price for that instance type before instances are
-- launched. For example, if your maximum percentage is 20%, then the Spot
-- price must be less than 20% of the current On-Demand price for that
-- Amazon EC2 instance. You always pay the lowest (market) price and never
-- more than your maximum percentage. If you leave this field empty, the
-- default value is 100% of the On-Demand price.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
computeResource_bidPercentage :: Lens.Lens' ComputeResource (Prelude.Maybe Prelude.Int)
computeResource_bidPercentage :: (Maybe Int -> f (Maybe Int))
-> ComputeResource -> f ComputeResource
computeResource_bidPercentage = (ComputeResource -> Maybe Int)
-> (ComputeResource -> Maybe Int -> ComputeResource)
-> Lens ComputeResource ComputeResource (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {Maybe Int
bidPercentage :: Maybe Int
$sel:bidPercentage:ComputeResource' :: ComputeResource -> Maybe Int
bidPercentage} -> Maybe Int
bidPercentage) (\s :: ComputeResource
s@ComputeResource' {} Maybe Int
a -> ComputeResource
s {$sel:bidPercentage:ComputeResource' :: Maybe Int
bidPercentage = Maybe Int
a} :: ComputeResource)

-- | The Amazon Resource Name (ARN) of the Amazon EC2 Spot Fleet IAM role
-- applied to a @SPOT@ compute environment. This role is required if the
-- allocation strategy set to @BEST_FIT@ or if the allocation strategy
-- isn\'t specified. For more information, see
-- <https://docs.aws.amazon.com/batch/latest/userguide/spot_fleet_IAM_role.html Amazon EC2 Spot Fleet Role>
-- in the /Batch User Guide/.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- To tag your Spot Instances on creation, the Spot Fleet IAM role
-- specified here must use the newer __AmazonEC2SpotFleetTaggingRole__
-- managed policy. The previously recommended __AmazonEC2SpotFleetRole__
-- managed policy doesn\'t have the required permissions to tag Spot
-- Instances. For more information, see
-- <https://docs.aws.amazon.com/batch/latest/userguide/troubleshooting.html#spot-instance-no-tag Spot Instances not tagged on creation>
-- in the /Batch User Guide/.
computeResource_spotIamFleetRole :: Lens.Lens' ComputeResource (Prelude.Maybe Prelude.Text)
computeResource_spotIamFleetRole :: (Maybe Text -> f (Maybe Text))
-> ComputeResource -> f ComputeResource
computeResource_spotIamFleetRole = (ComputeResource -> Maybe Text)
-> (ComputeResource -> Maybe Text -> ComputeResource)
-> Lens ComputeResource ComputeResource (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {Maybe Text
spotIamFleetRole :: Maybe Text
$sel:spotIamFleetRole:ComputeResource' :: ComputeResource -> Maybe Text
spotIamFleetRole} -> Maybe Text
spotIamFleetRole) (\s :: ComputeResource
s@ComputeResource' {} Maybe Text
a -> ComputeResource
s {$sel:spotIamFleetRole:ComputeResource' :: Maybe Text
spotIamFleetRole = Maybe Text
a} :: ComputeResource)

-- | The Amazon Machine Image (AMI) ID used for instances launched in the
-- compute environment. This parameter is overridden by the
-- @imageIdOverride@ member of the @Ec2Configuration@ structure.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- The AMI that you choose for a compute environment must match the
-- architecture of the instance types that you intend to use for that
-- compute environment. For example, if your compute environment uses A1
-- instance types, the compute resource AMI that you choose must support
-- ARM instances. Amazon ECS vends both x86 and ARM versions of the Amazon
-- ECS-optimized Amazon Linux 2 AMI. For more information, see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#ecs-optimized-ami-linux-variants.html Amazon ECS-optimized Amazon Linux 2 AMI>
-- in the /Amazon Elastic Container Service Developer Guide/.
computeResource_imageId :: Lens.Lens' ComputeResource (Prelude.Maybe Prelude.Text)
computeResource_imageId :: (Maybe Text -> f (Maybe Text))
-> ComputeResource -> f ComputeResource
computeResource_imageId = (ComputeResource -> Maybe Text)
-> (ComputeResource -> Maybe Text -> ComputeResource)
-> Lens ComputeResource ComputeResource (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {Maybe Text
imageId :: Maybe Text
$sel:imageId:ComputeResource' :: ComputeResource -> Maybe Text
imageId} -> Maybe Text
imageId) (\s :: ComputeResource
s@ComputeResource' {} Maybe Text
a -> ComputeResource
s {$sel:imageId:ComputeResource' :: Maybe Text
imageId = Maybe Text
a} :: ComputeResource)

-- | The launch template to use for your compute resources. Any other compute
-- resource parameters that you specify in a CreateComputeEnvironment API
-- operation override the same parameters in the launch template. You must
-- specify either the launch template ID or launch template name in the
-- request, but not both. For more information, see
-- <https://docs.aws.amazon.com/batch/latest/userguide/launch-templates.html Launch Template Support>
-- in the /Batch User Guide/.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
computeResource_launchTemplate :: Lens.Lens' ComputeResource (Prelude.Maybe LaunchTemplateSpecification)
computeResource_launchTemplate :: (Maybe LaunchTemplateSpecification
 -> f (Maybe LaunchTemplateSpecification))
-> ComputeResource -> f ComputeResource
computeResource_launchTemplate = (ComputeResource -> Maybe LaunchTemplateSpecification)
-> (ComputeResource
    -> Maybe LaunchTemplateSpecification -> ComputeResource)
-> Lens
     ComputeResource
     ComputeResource
     (Maybe LaunchTemplateSpecification)
     (Maybe LaunchTemplateSpecification)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {Maybe LaunchTemplateSpecification
launchTemplate :: Maybe LaunchTemplateSpecification
$sel:launchTemplate:ComputeResource' :: ComputeResource -> Maybe LaunchTemplateSpecification
launchTemplate} -> Maybe LaunchTemplateSpecification
launchTemplate) (\s :: ComputeResource
s@ComputeResource' {} Maybe LaunchTemplateSpecification
a -> ComputeResource
s {$sel:launchTemplate:ComputeResource' :: Maybe LaunchTemplateSpecification
launchTemplate = Maybe LaunchTemplateSpecification
a} :: ComputeResource)

-- | The desired number of Amazon EC2 vCPUS in the compute environment. Batch
-- modifies this value between the minimum and maximum values, based on job
-- queue demand.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
computeResource_desiredvCpus :: Lens.Lens' ComputeResource (Prelude.Maybe Prelude.Int)
computeResource_desiredvCpus :: (Maybe Int -> f (Maybe Int))
-> ComputeResource -> f ComputeResource
computeResource_desiredvCpus = (ComputeResource -> Maybe Int)
-> (ComputeResource -> Maybe Int -> ComputeResource)
-> Lens ComputeResource ComputeResource (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {Maybe Int
desiredvCpus :: Maybe Int
$sel:desiredvCpus:ComputeResource' :: ComputeResource -> Maybe Int
desiredvCpus} -> Maybe Int
desiredvCpus) (\s :: ComputeResource
s@ComputeResource' {} Maybe Int
a -> ComputeResource
s {$sel:desiredvCpus:ComputeResource' :: Maybe Int
desiredvCpus = Maybe Int
a} :: ComputeResource)

-- | The allocation strategy to use for the compute resource if not enough
-- instances of the best fitting instance type can be allocated. This might
-- be because of availability of the instance type in the Region or
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-resource-limits.html Amazon EC2 service limits>.
-- For more information, see
-- <https://docs.aws.amazon.com/batch/latest/userguide/allocation-strategies.html Allocation Strategies>
-- in the /Batch User Guide/.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
--
-- [BEST_FIT (default)]
--     Batch selects an instance type that best fits the needs of the jobs
--     with a preference for the lowest-cost instance type. If additional
--     instances of the selected instance type aren\'t available, Batch
--     waits for the additional instances to be available. If there aren\'t
--     enough instances available, or if the user is reaching
--     <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-resource-limits.html Amazon EC2 service limits>
--     then additional jobs aren\'t run until the currently running jobs
--     have completed. This allocation strategy keeps costs lower but can
--     limit scaling. If you are using Spot Fleets with @BEST_FIT@ then the
--     Spot Fleet IAM Role must be specified.
--
-- [BEST_FIT_PROGRESSIVE]
--     Batch will select additional instance types that are large enough to
--     meet the requirements of the jobs in the queue, with a preference
--     for instance types with a lower cost per unit vCPU. If additional
--     instances of the previously selected instance types aren\'t
--     available, Batch will select new instance types.
--
-- [SPOT_CAPACITY_OPTIMIZED]
--     Batch will select one or more instance types that are large enough
--     to meet the requirements of the jobs in the queue, with a preference
--     for instance types that are less likely to be interrupted. This
--     allocation strategy is only available for Spot Instance compute
--     resources.
--
-- With both @BEST_FIT_PROGRESSIVE@ and @SPOT_CAPACITY_OPTIMIZED@
-- strategies, Batch might need to go above @maxvCpus@ to meet your
-- capacity requirements. In this event, Batch never exceeds @maxvCpus@ by
-- more than a single instance.
computeResource_allocationStrategy :: Lens.Lens' ComputeResource (Prelude.Maybe CRAllocationStrategy)
computeResource_allocationStrategy :: (Maybe CRAllocationStrategy -> f (Maybe CRAllocationStrategy))
-> ComputeResource -> f ComputeResource
computeResource_allocationStrategy = (ComputeResource -> Maybe CRAllocationStrategy)
-> (ComputeResource
    -> Maybe CRAllocationStrategy -> ComputeResource)
-> Lens
     ComputeResource
     ComputeResource
     (Maybe CRAllocationStrategy)
     (Maybe CRAllocationStrategy)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {Maybe CRAllocationStrategy
allocationStrategy :: Maybe CRAllocationStrategy
$sel:allocationStrategy:ComputeResource' :: ComputeResource -> Maybe CRAllocationStrategy
allocationStrategy} -> Maybe CRAllocationStrategy
allocationStrategy) (\s :: ComputeResource
s@ComputeResource' {} Maybe CRAllocationStrategy
a -> ComputeResource
s {$sel:allocationStrategy:ComputeResource' :: Maybe CRAllocationStrategy
allocationStrategy = Maybe CRAllocationStrategy
a} :: ComputeResource)

-- | The Amazon EC2 placement group to associate with your compute resources.
-- If you intend to submit multi-node parallel jobs to your compute
-- environment, you should consider creating a cluster placement group and
-- associate it with your compute resources. This keeps your multi-node
-- parallel job on a logical grouping of instances within a single
-- Availability Zone with high network flow potential. For more
-- information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html Placement Groups>
-- in the /Amazon EC2 User Guide for Linux Instances/.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
computeResource_placementGroup :: Lens.Lens' ComputeResource (Prelude.Maybe Prelude.Text)
computeResource_placementGroup :: (Maybe Text -> f (Maybe Text))
-> ComputeResource -> f ComputeResource
computeResource_placementGroup = (ComputeResource -> Maybe Text)
-> (ComputeResource -> Maybe Text -> ComputeResource)
-> Lens ComputeResource ComputeResource (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {Maybe Text
placementGroup :: Maybe Text
$sel:placementGroup:ComputeResource' :: ComputeResource -> Maybe Text
placementGroup} -> Maybe Text
placementGroup) (\s :: ComputeResource
s@ComputeResource' {} Maybe Text
a -> ComputeResource
s {$sel:placementGroup:ComputeResource' :: Maybe Text
placementGroup = Maybe Text
a} :: ComputeResource)

-- | Key-value pair tags to be applied to EC2 resources that are launched in
-- the compute environment. For Batch, these take the form of \"String1\":
-- \"String2\", where String1 is the tag key and String2 is the tag
-- value−for example, @{ \"Name\": \"Batch Instance - C4OnDemand\" }@. This
-- is helpful for recognizing your Batch instances in the Amazon EC2
-- console. These tags can\'t be updated or removed after the compute
-- environment is created.Aany changes to these tags require that you
-- create a new compute environment and remove the old compute environment.
-- These tags aren\'t seen when using the Batch @ListTagsForResource@ API
-- operation.
--
-- This parameter isn\'t applicable to jobs that are running on Fargate
-- resources, and shouldn\'t be specified.
computeResource_tags :: Lens.Lens' ComputeResource (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
computeResource_tags :: (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> ComputeResource -> f ComputeResource
computeResource_tags = (ComputeResource -> Maybe (HashMap Text Text))
-> (ComputeResource
    -> Maybe (HashMap Text Text) -> ComputeResource)
-> Lens
     ComputeResource
     ComputeResource
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:ComputeResource' :: ComputeResource -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: ComputeResource
s@ComputeResource' {} Maybe (HashMap Text Text)
a -> ComputeResource
s {$sel:tags:ComputeResource' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: ComputeResource) ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
 -> ComputeResource -> f ComputeResource)
-> ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
    -> Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> ComputeResource
-> f ComputeResource
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
-> Iso
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The type of compute environment: @EC2@, @SPOT@, @FARGATE@, or
-- @FARGATE_SPOT@. For more information, see
-- <https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html Compute Environments>
-- in the /Batch User Guide/.
--
-- If you choose @SPOT@, you must also specify an Amazon EC2 Spot Fleet
-- role with the @spotIamFleetRole@ parameter. For more information, see
-- <https://docs.aws.amazon.com/batch/latest/userguide/spot_fleet_IAM_role.html Amazon EC2 Spot Fleet role>
-- in the /Batch User Guide/.
computeResource_type :: Lens.Lens' ComputeResource CRType
computeResource_type :: (CRType -> f CRType) -> ComputeResource -> f ComputeResource
computeResource_type = (ComputeResource -> CRType)
-> (ComputeResource -> CRType -> ComputeResource)
-> Lens ComputeResource ComputeResource CRType CRType
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {CRType
type' :: CRType
$sel:type':ComputeResource' :: ComputeResource -> CRType
type'} -> CRType
type') (\s :: ComputeResource
s@ComputeResource' {} CRType
a -> ComputeResource
s {$sel:type':ComputeResource' :: CRType
type' = CRType
a} :: ComputeResource)

-- | The maximum number of Amazon EC2 vCPUs that a compute environment can
-- reach.
--
-- With both @BEST_FIT_PROGRESSIVE@ and @SPOT_CAPACITY_OPTIMIZED@
-- allocation strategies, Batch might need to exceed @maxvCpus@ to meet
-- your capacity requirements. In this event, Batch never exceeds
-- @maxvCpus@ by more than a single instance. For example, no more than a
-- single instance from among those specified in your compute environment
-- is allocated.
computeResource_maxvCpus :: Lens.Lens' ComputeResource Prelude.Int
computeResource_maxvCpus :: (Int -> f Int) -> ComputeResource -> f ComputeResource
computeResource_maxvCpus = (ComputeResource -> Int)
-> (ComputeResource -> Int -> ComputeResource)
-> Lens ComputeResource ComputeResource Int Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {Int
maxvCpus :: Int
$sel:maxvCpus:ComputeResource' :: ComputeResource -> Int
maxvCpus} -> Int
maxvCpus) (\s :: ComputeResource
s@ComputeResource' {} Int
a -> ComputeResource
s {$sel:maxvCpus:ComputeResource' :: Int
maxvCpus = Int
a} :: ComputeResource)

-- | The VPC subnets where the compute resources are launched. These subnets
-- must be within the same VPC. Fargate compute resources can contain up to
-- 16 subnets. For more information, see
-- <https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html VPCs and Subnets>
-- in the /Amazon VPC User Guide/.
computeResource_subnets :: Lens.Lens' ComputeResource [Prelude.Text]
computeResource_subnets :: ([Text] -> f [Text]) -> ComputeResource -> f ComputeResource
computeResource_subnets = (ComputeResource -> [Text])
-> (ComputeResource -> [Text] -> ComputeResource)
-> Lens ComputeResource ComputeResource [Text] [Text]
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ComputeResource' {[Text]
subnets :: [Text]
$sel:subnets:ComputeResource' :: ComputeResource -> [Text]
subnets} -> [Text]
subnets) (\s :: ComputeResource
s@ComputeResource' {} [Text]
a -> ComputeResource
s {$sel:subnets:ComputeResource' :: [Text]
subnets = [Text]
a} :: ComputeResource) (([Text] -> f [Text]) -> ComputeResource -> f ComputeResource)
-> (([Text] -> f [Text]) -> [Text] -> f [Text])
-> ([Text] -> f [Text])
-> ComputeResource
-> f ComputeResource
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. ([Text] -> f [Text]) -> [Text] -> f [Text]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Core.FromJSON ComputeResource where
  parseJSON :: Value -> Parser ComputeResource
parseJSON =
    String
-> (Object -> Parser ComputeResource)
-> Value
-> Parser ComputeResource
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"ComputeResource"
      ( \Object
x ->
          Maybe [Text]
-> Maybe [Text]
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe [Ec2Configuration]
-> Maybe Int
-> Maybe Text
-> Maybe Text
-> Maybe LaunchTemplateSpecification
-> Maybe Int
-> Maybe CRAllocationStrategy
-> Maybe Text
-> Maybe (HashMap Text Text)
-> CRType
-> Int
-> [Text]
-> ComputeResource
ComputeResource'
            (Maybe [Text]
 -> Maybe [Text]
 -> Maybe Text
 -> Maybe Text
 -> Maybe Int
 -> Maybe [Ec2Configuration]
 -> Maybe Int
 -> Maybe Text
 -> Maybe Text
 -> Maybe LaunchTemplateSpecification
 -> Maybe Int
 -> Maybe CRAllocationStrategy
 -> Maybe Text
 -> Maybe (HashMap Text Text)
 -> CRType
 -> Int
 -> [Text]
 -> ComputeResource)
-> Parser (Maybe [Text])
-> Parser
     (Maybe [Text]
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe [Ec2Configuration]
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe LaunchTemplateSpecification
      -> Maybe Int
      -> Maybe CRAllocationStrategy
      -> Maybe Text
      -> Maybe (HashMap Text Text)
      -> CRType
      -> Int
      -> [Text]
      -> ComputeResource)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ( Object
x Object -> Text -> Parser (Maybe (Maybe [Text]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"securityGroupIds"
                            Parser (Maybe (Maybe [Text]))
-> Maybe [Text] -> Parser (Maybe [Text])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [Text]
forall a. Monoid a => a
Prelude.mempty
                        )
            Parser
  (Maybe [Text]
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe [Ec2Configuration]
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe LaunchTemplateSpecification
   -> Maybe Int
   -> Maybe CRAllocationStrategy
   -> Maybe Text
   -> Maybe (HashMap Text Text)
   -> CRType
   -> Int
   -> [Text]
   -> ComputeResource)
-> Parser (Maybe [Text])
-> Parser
     (Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe [Ec2Configuration]
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe LaunchTemplateSpecification
      -> Maybe Int
      -> Maybe CRAllocationStrategy
      -> Maybe Text
      -> Maybe (HashMap Text Text)
      -> CRType
      -> Int
      -> [Text]
      -> ComputeResource)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe (Maybe [Text]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"instanceTypes" Parser (Maybe (Maybe [Text]))
-> Maybe [Text] -> Parser (Maybe [Text])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [Text]
forall a. Monoid a => a
Prelude.mempty)
            Parser
  (Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe [Ec2Configuration]
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe LaunchTemplateSpecification
   -> Maybe Int
   -> Maybe CRAllocationStrategy
   -> Maybe Text
   -> Maybe (HashMap Text Text)
   -> CRType
   -> Int
   -> [Text]
   -> ComputeResource)
-> Parser (Maybe Text)
-> Parser
     (Maybe Text
      -> Maybe Int
      -> Maybe [Ec2Configuration]
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe LaunchTemplateSpecification
      -> Maybe Int
      -> Maybe CRAllocationStrategy
      -> Maybe Text
      -> Maybe (HashMap Text Text)
      -> CRType
      -> Int
      -> [Text]
      -> ComputeResource)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"instanceRole")
            Parser
  (Maybe Text
   -> Maybe Int
   -> Maybe [Ec2Configuration]
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe LaunchTemplateSpecification
   -> Maybe Int
   -> Maybe CRAllocationStrategy
   -> Maybe Text
   -> Maybe (HashMap Text Text)
   -> CRType
   -> Int
   -> [Text]
   -> ComputeResource)
-> Parser (Maybe Text)
-> Parser
     (Maybe Int
      -> Maybe [Ec2Configuration]
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe LaunchTemplateSpecification
      -> Maybe Int
      -> Maybe CRAllocationStrategy
      -> Maybe Text
      -> Maybe (HashMap Text Text)
      -> CRType
      -> Int
      -> [Text]
      -> ComputeResource)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"ec2KeyPair")
            Parser
  (Maybe Int
   -> Maybe [Ec2Configuration]
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe LaunchTemplateSpecification
   -> Maybe Int
   -> Maybe CRAllocationStrategy
   -> Maybe Text
   -> Maybe (HashMap Text Text)
   -> CRType
   -> Int
   -> [Text]
   -> ComputeResource)
-> Parser (Maybe Int)
-> Parser
     (Maybe [Ec2Configuration]
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe LaunchTemplateSpecification
      -> Maybe Int
      -> Maybe CRAllocationStrategy
      -> Maybe Text
      -> Maybe (HashMap Text Text)
      -> CRType
      -> Int
      -> [Text]
      -> ComputeResource)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"minvCpus")
            Parser
  (Maybe [Ec2Configuration]
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe LaunchTemplateSpecification
   -> Maybe Int
   -> Maybe CRAllocationStrategy
   -> Maybe Text
   -> Maybe (HashMap Text Text)
   -> CRType
   -> Int
   -> [Text]
   -> ComputeResource)
-> Parser (Maybe [Ec2Configuration])
-> Parser
     (Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe LaunchTemplateSpecification
      -> Maybe Int
      -> Maybe CRAllocationStrategy
      -> Maybe Text
      -> Maybe (HashMap Text Text)
      -> CRType
      -> Int
      -> [Text]
      -> ComputeResource)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object -> Text -> Parser (Maybe (Maybe [Ec2Configuration]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"ec2Configuration"
                            Parser (Maybe (Maybe [Ec2Configuration]))
-> Maybe [Ec2Configuration] -> Parser (Maybe [Ec2Configuration])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [Ec2Configuration]
forall a. Monoid a => a
Prelude.mempty
                        )
            Parser
  (Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe LaunchTemplateSpecification
   -> Maybe Int
   -> Maybe CRAllocationStrategy
   -> Maybe Text
   -> Maybe (HashMap Text Text)
   -> CRType
   -> Int
   -> [Text]
   -> ComputeResource)
-> Parser (Maybe Int)
-> Parser
     (Maybe Text
      -> Maybe Text
      -> Maybe LaunchTemplateSpecification
      -> Maybe Int
      -> Maybe CRAllocationStrategy
      -> Maybe Text
      -> Maybe (HashMap Text Text)
      -> CRType
      -> Int
      -> [Text]
      -> ComputeResource)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"bidPercentage")
            Parser
  (Maybe Text
   -> Maybe Text
   -> Maybe LaunchTemplateSpecification
   -> Maybe Int
   -> Maybe CRAllocationStrategy
   -> Maybe Text
   -> Maybe (HashMap Text Text)
   -> CRType
   -> Int
   -> [Text]
   -> ComputeResource)
-> Parser (Maybe Text)
-> Parser
     (Maybe Text
      -> Maybe LaunchTemplateSpecification
      -> Maybe Int
      -> Maybe CRAllocationStrategy
      -> Maybe Text
      -> Maybe (HashMap Text Text)
      -> CRType
      -> Int
      -> [Text]
      -> ComputeResource)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"spotIamFleetRole")
            Parser
  (Maybe Text
   -> Maybe LaunchTemplateSpecification
   -> Maybe Int
   -> Maybe CRAllocationStrategy
   -> Maybe Text
   -> Maybe (HashMap Text Text)
   -> CRType
   -> Int
   -> [Text]
   -> ComputeResource)
-> Parser (Maybe Text)
-> Parser
     (Maybe LaunchTemplateSpecification
      -> Maybe Int
      -> Maybe CRAllocationStrategy
      -> Maybe Text
      -> Maybe (HashMap Text Text)
      -> CRType
      -> Int
      -> [Text]
      -> ComputeResource)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"imageId")
            Parser
  (Maybe LaunchTemplateSpecification
   -> Maybe Int
   -> Maybe CRAllocationStrategy
   -> Maybe Text
   -> Maybe (HashMap Text Text)
   -> CRType
   -> Int
   -> [Text]
   -> ComputeResource)
-> Parser (Maybe LaunchTemplateSpecification)
-> Parser
     (Maybe Int
      -> Maybe CRAllocationStrategy
      -> Maybe Text
      -> Maybe (HashMap Text Text)
      -> CRType
      -> Int
      -> [Text]
      -> ComputeResource)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe LaunchTemplateSpecification)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"launchTemplate")
            Parser
  (Maybe Int
   -> Maybe CRAllocationStrategy
   -> Maybe Text
   -> Maybe (HashMap Text Text)
   -> CRType
   -> Int
   -> [Text]
   -> ComputeResource)
-> Parser (Maybe Int)
-> Parser
     (Maybe CRAllocationStrategy
      -> Maybe Text
      -> Maybe (HashMap Text Text)
      -> CRType
      -> Int
      -> [Text]
      -> ComputeResource)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"desiredvCpus")
            Parser
  (Maybe CRAllocationStrategy
   -> Maybe Text
   -> Maybe (HashMap Text Text)
   -> CRType
   -> Int
   -> [Text]
   -> ComputeResource)
-> Parser (Maybe CRAllocationStrategy)
-> Parser
     (Maybe Text
      -> Maybe (HashMap Text Text)
      -> CRType
      -> Int
      -> [Text]
      -> ComputeResource)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe CRAllocationStrategy)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"allocationStrategy")
            Parser
  (Maybe Text
   -> Maybe (HashMap Text Text)
   -> CRType
   -> Int
   -> [Text]
   -> ComputeResource)
-> Parser (Maybe Text)
-> Parser
     (Maybe (HashMap Text Text)
      -> CRType -> Int -> [Text] -> ComputeResource)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"placementGroup")
            Parser
  (Maybe (HashMap Text Text)
   -> CRType -> Int -> [Text] -> ComputeResource)
-> Parser (Maybe (HashMap Text Text))
-> Parser (CRType -> Int -> [Text] -> ComputeResource)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe (Maybe (HashMap Text Text)))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"tags" Parser (Maybe (Maybe (HashMap Text Text)))
-> Maybe (HashMap Text Text) -> Parser (Maybe (HashMap Text Text))
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe (HashMap Text Text)
forall a. Monoid a => a
Prelude.mempty)
            Parser (CRType -> Int -> [Text] -> ComputeResource)
-> Parser CRType -> Parser (Int -> [Text] -> ComputeResource)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser CRType
forall a. FromJSON a => Object -> Text -> Parser a
Core..: Text
"type")
            Parser (Int -> [Text] -> ComputeResource)
-> Parser Int -> Parser ([Text] -> ComputeResource)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser Int
forall a. FromJSON a => Object -> Text -> Parser a
Core..: Text
"maxvCpus")
            Parser ([Text] -> ComputeResource)
-> Parser [Text] -> Parser ComputeResource
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe [Text])
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"subnets" Parser (Maybe [Text]) -> [Text] -> Parser [Text]
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= [Text]
forall a. Monoid a => a
Prelude.mempty)
      )

instance Prelude.Hashable ComputeResource

instance Prelude.NFData ComputeResource

instance Core.ToJSON ComputeResource where
  toJSON :: ComputeResource -> Value
toJSON ComputeResource' {Int
[Text]
Maybe Int
Maybe [Text]
Maybe [Ec2Configuration]
Maybe Text
Maybe (HashMap Text Text)
Maybe CRAllocationStrategy
Maybe LaunchTemplateSpecification
CRType
subnets :: [Text]
maxvCpus :: Int
type' :: CRType
tags :: Maybe (HashMap Text Text)
placementGroup :: Maybe Text
allocationStrategy :: Maybe CRAllocationStrategy
desiredvCpus :: Maybe Int
launchTemplate :: Maybe LaunchTemplateSpecification
imageId :: Maybe Text
spotIamFleetRole :: Maybe Text
bidPercentage :: Maybe Int
ec2Configuration :: Maybe [Ec2Configuration]
minvCpus :: Maybe Int
ec2KeyPair :: Maybe Text
instanceRole :: Maybe Text
instanceTypes :: Maybe [Text]
securityGroupIds :: Maybe [Text]
$sel:subnets:ComputeResource' :: ComputeResource -> [Text]
$sel:maxvCpus:ComputeResource' :: ComputeResource -> Int
$sel:type':ComputeResource' :: ComputeResource -> CRType
$sel:tags:ComputeResource' :: ComputeResource -> Maybe (HashMap Text Text)
$sel:placementGroup:ComputeResource' :: ComputeResource -> Maybe Text
$sel:allocationStrategy:ComputeResource' :: ComputeResource -> Maybe CRAllocationStrategy
$sel:desiredvCpus:ComputeResource' :: ComputeResource -> Maybe Int
$sel:launchTemplate:ComputeResource' :: ComputeResource -> Maybe LaunchTemplateSpecification
$sel:imageId:ComputeResource' :: ComputeResource -> Maybe Text
$sel:spotIamFleetRole:ComputeResource' :: ComputeResource -> Maybe Text
$sel:bidPercentage:ComputeResource' :: ComputeResource -> Maybe Int
$sel:ec2Configuration:ComputeResource' :: ComputeResource -> Maybe [Ec2Configuration]
$sel:minvCpus:ComputeResource' :: ComputeResource -> Maybe Int
$sel:ec2KeyPair:ComputeResource' :: ComputeResource -> Maybe Text
$sel:instanceRole:ComputeResource' :: ComputeResource -> Maybe Text
$sel:instanceTypes:ComputeResource' :: ComputeResource -> Maybe [Text]
$sel:securityGroupIds:ComputeResource' :: ComputeResource -> Maybe [Text]
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"securityGroupIds" Text -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              ([Text] -> Pair) -> Maybe [Text] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
securityGroupIds,
            (Text
"instanceTypes" Text -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) ([Text] -> Pair) -> Maybe [Text] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
instanceTypes,
            (Text
"instanceRole" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
instanceRole,
            (Text
"ec2KeyPair" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
ec2KeyPair,
            (Text
"minvCpus" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Int
minvCpus,
            (Text
"ec2Configuration" Text -> [Ec2Configuration] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              ([Ec2Configuration] -> Pair)
-> Maybe [Ec2Configuration] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Ec2Configuration]
ec2Configuration,
            (Text
"bidPercentage" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Int
bidPercentage,
            (Text
"spotIamFleetRole" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
spotIamFleetRole,
            (Text
"imageId" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
imageId,
            (Text
"launchTemplate" Text -> LaunchTemplateSpecification -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (LaunchTemplateSpecification -> Pair)
-> Maybe LaunchTemplateSpecification -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe LaunchTemplateSpecification
launchTemplate,
            (Text
"desiredvCpus" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Int
desiredvCpus,
            (Text
"allocationStrategy" Text -> CRAllocationStrategy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (CRAllocationStrategy -> Pair)
-> Maybe CRAllocationStrategy -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe CRAllocationStrategy
allocationStrategy,
            (Text
"placementGroup" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
placementGroup,
            (Text
"tags" Text -> HashMap Text Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (HashMap Text Text -> Pair)
-> Maybe (HashMap Text Text) -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (HashMap Text Text)
tags,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"type" Text -> CRType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= CRType
type'),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"maxvCpus" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Int
maxvCpus),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"subnets" Text -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= [Text]
subnets)
          ]
      )