{-# 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.ECS.Types.TaskOverride
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.ECS.Types.TaskOverride where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.ECS.Types.ContainerOverride
import Amazonka.ECS.Types.EphemeralStorage
import Amazonka.ECS.Types.InferenceAcceleratorOverride
import qualified Amazonka.Prelude as Prelude

-- | The overrides that are associated with a task.
--
-- /See:/ 'newTaskOverride' smart constructor.
data TaskOverride = TaskOverride'
  { -- | One or more container overrides that are sent to a task.
    TaskOverride -> Maybe [ContainerOverride]
containerOverrides :: Prelude.Maybe [ContainerOverride],
    -- | The CPU override for the task.
    TaskOverride -> Maybe Text
cpu :: Prelude.Maybe Prelude.Text,
    -- | The ephemeral storage setting override for the task.
    --
    -- This parameter is only supported for tasks hosted on Fargate that use
    -- the following platform versions:
    --
    -- -   Linux platform version @1.4.0@ or later.
    --
    -- -   Windows platform version @1.0.0@ or later.
    TaskOverride -> Maybe EphemeralStorage
ephemeralStorage :: Prelude.Maybe EphemeralStorage,
    -- | The Amazon Resource Name (ARN) of the task execution IAM role override
    -- for the task. For more information, see
    -- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html Amazon ECS task execution IAM role>
    -- in the /Amazon Elastic Container Service Developer Guide/.
    TaskOverride -> Maybe Text
executionRoleArn :: Prelude.Maybe Prelude.Text,
    -- | The Elastic Inference accelerator override for the task.
    TaskOverride -> Maybe [InferenceAcceleratorOverride]
inferenceAcceleratorOverrides :: Prelude.Maybe [InferenceAcceleratorOverride],
    -- | The memory override for the task.
    TaskOverride -> Maybe Text
memory :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Resource Name (ARN) of the IAM role that containers in this
    -- task can assume. All containers in this task are granted the permissions
    -- that are specified in this role. For more information, see
    -- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html IAM Role for Tasks>
    -- in the /Amazon Elastic Container Service Developer Guide/.
    TaskOverride -> Maybe Text
taskRoleArn :: Prelude.Maybe Prelude.Text
  }
  deriving (TaskOverride -> TaskOverride -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TaskOverride -> TaskOverride -> Bool
$c/= :: TaskOverride -> TaskOverride -> Bool
== :: TaskOverride -> TaskOverride -> Bool
$c== :: TaskOverride -> TaskOverride -> Bool
Prelude.Eq, ReadPrec [TaskOverride]
ReadPrec TaskOverride
Int -> ReadS TaskOverride
ReadS [TaskOverride]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TaskOverride]
$creadListPrec :: ReadPrec [TaskOverride]
readPrec :: ReadPrec TaskOverride
$creadPrec :: ReadPrec TaskOverride
readList :: ReadS [TaskOverride]
$creadList :: ReadS [TaskOverride]
readsPrec :: Int -> ReadS TaskOverride
$creadsPrec :: Int -> ReadS TaskOverride
Prelude.Read, Int -> TaskOverride -> ShowS
[TaskOverride] -> ShowS
TaskOverride -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TaskOverride] -> ShowS
$cshowList :: [TaskOverride] -> ShowS
show :: TaskOverride -> String
$cshow :: TaskOverride -> String
showsPrec :: Int -> TaskOverride -> ShowS
$cshowsPrec :: Int -> TaskOverride -> ShowS
Prelude.Show, forall x. Rep TaskOverride x -> TaskOverride
forall x. TaskOverride -> Rep TaskOverride x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TaskOverride x -> TaskOverride
$cfrom :: forall x. TaskOverride -> Rep TaskOverride x
Prelude.Generic)

-- |
-- Create a value of 'TaskOverride' 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:
--
-- 'containerOverrides', 'taskOverride_containerOverrides' - One or more container overrides that are sent to a task.
--
-- 'cpu', 'taskOverride_cpu' - The CPU override for the task.
--
-- 'ephemeralStorage', 'taskOverride_ephemeralStorage' - The ephemeral storage setting override for the task.
--
-- This parameter is only supported for tasks hosted on Fargate that use
-- the following platform versions:
--
-- -   Linux platform version @1.4.0@ or later.
--
-- -   Windows platform version @1.0.0@ or later.
--
-- 'executionRoleArn', 'taskOverride_executionRoleArn' - The Amazon Resource Name (ARN) of the task execution IAM role override
-- for the task. For more information, see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html Amazon ECS task execution IAM role>
-- in the /Amazon Elastic Container Service Developer Guide/.
--
-- 'inferenceAcceleratorOverrides', 'taskOverride_inferenceAcceleratorOverrides' - The Elastic Inference accelerator override for the task.
--
-- 'memory', 'taskOverride_memory' - The memory override for the task.
--
-- 'taskRoleArn', 'taskOverride_taskRoleArn' - The Amazon Resource Name (ARN) of the IAM role that containers in this
-- task can assume. All containers in this task are granted the permissions
-- that are specified in this role. For more information, see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html IAM Role for Tasks>
-- in the /Amazon Elastic Container Service Developer Guide/.
newTaskOverride ::
  TaskOverride
newTaskOverride :: TaskOverride
newTaskOverride =
  TaskOverride'
    { $sel:containerOverrides:TaskOverride' :: Maybe [ContainerOverride]
containerOverrides = forall a. Maybe a
Prelude.Nothing,
      $sel:cpu:TaskOverride' :: Maybe Text
cpu = forall a. Maybe a
Prelude.Nothing,
      $sel:ephemeralStorage:TaskOverride' :: Maybe EphemeralStorage
ephemeralStorage = forall a. Maybe a
Prelude.Nothing,
      $sel:executionRoleArn:TaskOverride' :: Maybe Text
executionRoleArn = forall a. Maybe a
Prelude.Nothing,
      $sel:inferenceAcceleratorOverrides:TaskOverride' :: Maybe [InferenceAcceleratorOverride]
inferenceAcceleratorOverrides = forall a. Maybe a
Prelude.Nothing,
      $sel:memory:TaskOverride' :: Maybe Text
memory = forall a. Maybe a
Prelude.Nothing,
      $sel:taskRoleArn:TaskOverride' :: Maybe Text
taskRoleArn = forall a. Maybe a
Prelude.Nothing
    }

-- | One or more container overrides that are sent to a task.
taskOverride_containerOverrides :: Lens.Lens' TaskOverride (Prelude.Maybe [ContainerOverride])
taskOverride_containerOverrides :: Lens' TaskOverride (Maybe [ContainerOverride])
taskOverride_containerOverrides = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TaskOverride' {Maybe [ContainerOverride]
containerOverrides :: Maybe [ContainerOverride]
$sel:containerOverrides:TaskOverride' :: TaskOverride -> Maybe [ContainerOverride]
containerOverrides} -> Maybe [ContainerOverride]
containerOverrides) (\s :: TaskOverride
s@TaskOverride' {} Maybe [ContainerOverride]
a -> TaskOverride
s {$sel:containerOverrides:TaskOverride' :: Maybe [ContainerOverride]
containerOverrides = Maybe [ContainerOverride]
a} :: TaskOverride) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The CPU override for the task.
taskOverride_cpu :: Lens.Lens' TaskOverride (Prelude.Maybe Prelude.Text)
taskOverride_cpu :: Lens' TaskOverride (Maybe Text)
taskOverride_cpu = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TaskOverride' {Maybe Text
cpu :: Maybe Text
$sel:cpu:TaskOverride' :: TaskOverride -> Maybe Text
cpu} -> Maybe Text
cpu) (\s :: TaskOverride
s@TaskOverride' {} Maybe Text
a -> TaskOverride
s {$sel:cpu:TaskOverride' :: Maybe Text
cpu = Maybe Text
a} :: TaskOverride)

-- | The ephemeral storage setting override for the task.
--
-- This parameter is only supported for tasks hosted on Fargate that use
-- the following platform versions:
--
-- -   Linux platform version @1.4.0@ or later.
--
-- -   Windows platform version @1.0.0@ or later.
taskOverride_ephemeralStorage :: Lens.Lens' TaskOverride (Prelude.Maybe EphemeralStorage)
taskOverride_ephemeralStorage :: Lens' TaskOverride (Maybe EphemeralStorage)
taskOverride_ephemeralStorage = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TaskOverride' {Maybe EphemeralStorage
ephemeralStorage :: Maybe EphemeralStorage
$sel:ephemeralStorage:TaskOverride' :: TaskOverride -> Maybe EphemeralStorage
ephemeralStorage} -> Maybe EphemeralStorage
ephemeralStorage) (\s :: TaskOverride
s@TaskOverride' {} Maybe EphemeralStorage
a -> TaskOverride
s {$sel:ephemeralStorage:TaskOverride' :: Maybe EphemeralStorage
ephemeralStorage = Maybe EphemeralStorage
a} :: TaskOverride)

-- | The Amazon Resource Name (ARN) of the task execution IAM role override
-- for the task. For more information, see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html Amazon ECS task execution IAM role>
-- in the /Amazon Elastic Container Service Developer Guide/.
taskOverride_executionRoleArn :: Lens.Lens' TaskOverride (Prelude.Maybe Prelude.Text)
taskOverride_executionRoleArn :: Lens' TaskOverride (Maybe Text)
taskOverride_executionRoleArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TaskOverride' {Maybe Text
executionRoleArn :: Maybe Text
$sel:executionRoleArn:TaskOverride' :: TaskOverride -> Maybe Text
executionRoleArn} -> Maybe Text
executionRoleArn) (\s :: TaskOverride
s@TaskOverride' {} Maybe Text
a -> TaskOverride
s {$sel:executionRoleArn:TaskOverride' :: Maybe Text
executionRoleArn = Maybe Text
a} :: TaskOverride)

-- | The Elastic Inference accelerator override for the task.
taskOverride_inferenceAcceleratorOverrides :: Lens.Lens' TaskOverride (Prelude.Maybe [InferenceAcceleratorOverride])
taskOverride_inferenceAcceleratorOverrides :: Lens' TaskOverride (Maybe [InferenceAcceleratorOverride])
taskOverride_inferenceAcceleratorOverrides = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TaskOverride' {Maybe [InferenceAcceleratorOverride]
inferenceAcceleratorOverrides :: Maybe [InferenceAcceleratorOverride]
$sel:inferenceAcceleratorOverrides:TaskOverride' :: TaskOverride -> Maybe [InferenceAcceleratorOverride]
inferenceAcceleratorOverrides} -> Maybe [InferenceAcceleratorOverride]
inferenceAcceleratorOverrides) (\s :: TaskOverride
s@TaskOverride' {} Maybe [InferenceAcceleratorOverride]
a -> TaskOverride
s {$sel:inferenceAcceleratorOverrides:TaskOverride' :: Maybe [InferenceAcceleratorOverride]
inferenceAcceleratorOverrides = Maybe [InferenceAcceleratorOverride]
a} :: TaskOverride) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The memory override for the task.
taskOverride_memory :: Lens.Lens' TaskOverride (Prelude.Maybe Prelude.Text)
taskOverride_memory :: Lens' TaskOverride (Maybe Text)
taskOverride_memory = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TaskOverride' {Maybe Text
memory :: Maybe Text
$sel:memory:TaskOverride' :: TaskOverride -> Maybe Text
memory} -> Maybe Text
memory) (\s :: TaskOverride
s@TaskOverride' {} Maybe Text
a -> TaskOverride
s {$sel:memory:TaskOverride' :: Maybe Text
memory = Maybe Text
a} :: TaskOverride)

-- | The Amazon Resource Name (ARN) of the IAM role that containers in this
-- task can assume. All containers in this task are granted the permissions
-- that are specified in this role. For more information, see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html IAM Role for Tasks>
-- in the /Amazon Elastic Container Service Developer Guide/.
taskOverride_taskRoleArn :: Lens.Lens' TaskOverride (Prelude.Maybe Prelude.Text)
taskOverride_taskRoleArn :: Lens' TaskOverride (Maybe Text)
taskOverride_taskRoleArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TaskOverride' {Maybe Text
taskRoleArn :: Maybe Text
$sel:taskRoleArn:TaskOverride' :: TaskOverride -> Maybe Text
taskRoleArn} -> Maybe Text
taskRoleArn) (\s :: TaskOverride
s@TaskOverride' {} Maybe Text
a -> TaskOverride
s {$sel:taskRoleArn:TaskOverride' :: Maybe Text
taskRoleArn = Maybe Text
a} :: TaskOverride)

instance Data.FromJSON TaskOverride where
  parseJSON :: Value -> Parser TaskOverride
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"TaskOverride"
      ( \Object
x ->
          Maybe [ContainerOverride]
-> Maybe Text
-> Maybe EphemeralStorage
-> Maybe Text
-> Maybe [InferenceAcceleratorOverride]
-> Maybe Text
-> Maybe Text
-> TaskOverride
TaskOverride'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"containerOverrides"
                            forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"cpu")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ephemeralStorage")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"executionRoleArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"inferenceAcceleratorOverrides"
                            forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"memory")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"taskRoleArn")
      )

instance Prelude.Hashable TaskOverride where
  hashWithSalt :: Int -> TaskOverride -> Int
hashWithSalt Int
_salt TaskOverride' {Maybe [InferenceAcceleratorOverride]
Maybe [ContainerOverride]
Maybe Text
Maybe EphemeralStorage
taskRoleArn :: Maybe Text
memory :: Maybe Text
inferenceAcceleratorOverrides :: Maybe [InferenceAcceleratorOverride]
executionRoleArn :: Maybe Text
ephemeralStorage :: Maybe EphemeralStorage
cpu :: Maybe Text
containerOverrides :: Maybe [ContainerOverride]
$sel:taskRoleArn:TaskOverride' :: TaskOverride -> Maybe Text
$sel:memory:TaskOverride' :: TaskOverride -> Maybe Text
$sel:inferenceAcceleratorOverrides:TaskOverride' :: TaskOverride -> Maybe [InferenceAcceleratorOverride]
$sel:executionRoleArn:TaskOverride' :: TaskOverride -> Maybe Text
$sel:ephemeralStorage:TaskOverride' :: TaskOverride -> Maybe EphemeralStorage
$sel:cpu:TaskOverride' :: TaskOverride -> Maybe Text
$sel:containerOverrides:TaskOverride' :: TaskOverride -> Maybe [ContainerOverride]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [ContainerOverride]
containerOverrides
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
cpu
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe EphemeralStorage
ephemeralStorage
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
executionRoleArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [InferenceAcceleratorOverride]
inferenceAcceleratorOverrides
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
memory
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
taskRoleArn

instance Prelude.NFData TaskOverride where
  rnf :: TaskOverride -> ()
rnf TaskOverride' {Maybe [InferenceAcceleratorOverride]
Maybe [ContainerOverride]
Maybe Text
Maybe EphemeralStorage
taskRoleArn :: Maybe Text
memory :: Maybe Text
inferenceAcceleratorOverrides :: Maybe [InferenceAcceleratorOverride]
executionRoleArn :: Maybe Text
ephemeralStorage :: Maybe EphemeralStorage
cpu :: Maybe Text
containerOverrides :: Maybe [ContainerOverride]
$sel:taskRoleArn:TaskOverride' :: TaskOverride -> Maybe Text
$sel:memory:TaskOverride' :: TaskOverride -> Maybe Text
$sel:inferenceAcceleratorOverrides:TaskOverride' :: TaskOverride -> Maybe [InferenceAcceleratorOverride]
$sel:executionRoleArn:TaskOverride' :: TaskOverride -> Maybe Text
$sel:ephemeralStorage:TaskOverride' :: TaskOverride -> Maybe EphemeralStorage
$sel:cpu:TaskOverride' :: TaskOverride -> Maybe Text
$sel:containerOverrides:TaskOverride' :: TaskOverride -> Maybe [ContainerOverride]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [ContainerOverride]
containerOverrides
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
cpu
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe EphemeralStorage
ephemeralStorage
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
executionRoleArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [InferenceAcceleratorOverride]
inferenceAcceleratorOverrides
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
memory
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
taskRoleArn

instance Data.ToJSON TaskOverride where
  toJSON :: TaskOverride -> Value
toJSON TaskOverride' {Maybe [InferenceAcceleratorOverride]
Maybe [ContainerOverride]
Maybe Text
Maybe EphemeralStorage
taskRoleArn :: Maybe Text
memory :: Maybe Text
inferenceAcceleratorOverrides :: Maybe [InferenceAcceleratorOverride]
executionRoleArn :: Maybe Text
ephemeralStorage :: Maybe EphemeralStorage
cpu :: Maybe Text
containerOverrides :: Maybe [ContainerOverride]
$sel:taskRoleArn:TaskOverride' :: TaskOverride -> Maybe Text
$sel:memory:TaskOverride' :: TaskOverride -> Maybe Text
$sel:inferenceAcceleratorOverrides:TaskOverride' :: TaskOverride -> Maybe [InferenceAcceleratorOverride]
$sel:executionRoleArn:TaskOverride' :: TaskOverride -> Maybe Text
$sel:ephemeralStorage:TaskOverride' :: TaskOverride -> Maybe EphemeralStorage
$sel:cpu:TaskOverride' :: TaskOverride -> Maybe Text
$sel:containerOverrides:TaskOverride' :: TaskOverride -> Maybe [ContainerOverride]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"containerOverrides" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [ContainerOverride]
containerOverrides,
            (Key
"cpu" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
cpu,
            (Key
"ephemeralStorage" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe EphemeralStorage
ephemeralStorage,
            (Key
"executionRoleArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
executionRoleArn,
            (Key
"inferenceAcceleratorOverrides" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [InferenceAcceleratorOverride]
inferenceAcceleratorOverrides,
            (Key
"memory" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
memory,
            (Key
"taskRoleArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
taskRoleArn
          ]
      )