types

package
v0.30.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 30, 2020 License: Apache-2.0 Imports: 2 Imported by: 10

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ArrayJobDependency 

type ArrayJobDependency string
const (
	ArrayJobDependencyNToN       ArrayJobDependency = "N_TO_N"
	ArrayJobDependencySequential ArrayJobDependency = "SEQUENTIAL"
)

Enum values for ArrayJobDependency

func (ArrayJobDependency) Values added in v0.29.0 

func (ArrayJobDependency) Values() []ArrayJobDependency

Values returns all known values for ArrayJobDependency. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

type ArrayProperties 

type ArrayProperties struct {

	// The size of the array job.
	Size int32
}

An object representing an AWS Batch array job.

type ArrayPropertiesDetail 

type ArrayPropertiesDetail struct {

	// The job index within the array that is associated with this job. This parameter
	// is returned for array job children.
	Index int32

	// The size of the array job. This parameter is returned for parent array jobs.
	Size int32

	// A summary of the number of array job children in each available job status. This
	// parameter is returned for parent array jobs.
	StatusSummary map[string]int32
}

An object representing the array properties of a job.

type ArrayPropertiesSummary 

type ArrayPropertiesSummary struct {

	// The job index within the array that is associated with this job. This parameter
	// is returned for children of array jobs.
	Index int32

	// The size of the array job. This parameter is returned for parent array jobs.
	Size int32
}

An object representing the array properties of a job.

type AttemptContainerDetail 

type AttemptContainerDetail struct {

	// The Amazon Resource Name (ARN) of the Amazon ECS container instance that hosts
	// the job attempt.
	ContainerInstanceArn *string

	// The exit code for the job attempt. A non-zero exit code is considered a failure.
	ExitCode int32

	// The name of the CloudWatch Logs log stream associated with the container. The
	// log group for AWS Batch jobs is /aws/batch/job. Each container attempt receives
	// a log stream name when they reach the RUNNING status.
	LogStreamName *string

	// The network interfaces associated with the job attempt.
	NetworkInterfaces []NetworkInterface

	// A short (255 max characters) human-readable string to provide additional details
	// about a running or stopped container.
	Reason *string

	// The Amazon Resource Name (ARN) of the Amazon ECS task that is associated with
	// the job attempt. Each container attempt receives a task ARN when they reach the
	// STARTING status.
	TaskArn *string
}

An object representing the details of a container that is part of a job attempt.

type AttemptDetail 

type AttemptDetail struct {

	// Details about the container in this job attempt.
	Container *AttemptContainerDetail

	// The Unix timestamp (in milliseconds) for when the attempt was started (when the
	// attempt transitioned from the STARTING state to the RUNNING state).
	StartedAt int64

	// A short, human-readable string to provide additional details about the current
	// status of the job attempt.
	StatusReason *string

	// The Unix timestamp (in milliseconds) for when the attempt was stopped (when the
	// attempt transitioned from the RUNNING state to a terminal state, such as
	// SUCCEEDED or FAILED).
	StoppedAt int64
}

An object representing a job attempt.

type CEState 

type CEState string
const (
	CEStateEnabled  CEState = "ENABLED"
	CEStateDisabled CEState = "DISABLED"
)

Enum values for CEState

func (CEState) Values added in v0.29.0 

func (CEState) Values() []CEState

Values returns all known values for CEState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

type CEStatus 

type CEStatus string
const (
	CEStatusCreating CEStatus = "CREATING"
	CEStatusUpdating CEStatus = "UPDATING"
	CEStatusDeleting CEStatus = "DELETING"
	CEStatusDeleted  CEStatus = "DELETED"
	CEStatusValid    CEStatus = "VALID"
	CEStatusInvalid  CEStatus = "INVALID"
)

Enum values for CEStatus

func (CEStatus) Values added in v0.29.0 

func (CEStatus) Values() []CEStatus

Values returns all known values for CEStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

type CEType 

type CEType string
const (
	CETypeManaged   CEType = "MANAGED"
	CETypeUnmanaged CEType = "UNMANAGED"
)

Enum values for CEType

func (CEType) Values added in v0.29.0 

func (CEType) Values() []CEType

Values returns all known values for CEType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

type CRAllocationStrategy 

type CRAllocationStrategy string
const (
	CRAllocationStrategyBestFit               CRAllocationStrategy = "BEST_FIT"
	CRAllocationStrategyBestFitProgressive    CRAllocationStrategy = "BEST_FIT_PROGRESSIVE"
	CRAllocationStrategySpotCapacityOptimized CRAllocationStrategy = "SPOT_CAPACITY_OPTIMIZED"
)

Enum values for CRAllocationStrategy

func (CRAllocationStrategy) Values added in v0.29.0 

func (CRAllocationStrategy) Values() []CRAllocationStrategy

Values returns all known values for CRAllocationStrategy. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

type CRType 

type CRType string
const (
	CRTypeEc2  CRType = "EC2"
	CRTypeSpot CRType = "SPOT"
)

Enum values for CRType

func (CRType) Values added in v0.29.0 

func (CRType) Values() []CRType

Values returns all known values for CRType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

type ClientException 

type ClientException struct {
	Message *string
}

These errors are usually caused by a client action, such as using an action or resource on behalf of a user that doesn't have permissions to use the action or resource, or specifying an identifier that is not valid.

func (*ClientException) Error 

func (e *ClientException) Error() string

func (*ClientException) ErrorCode 

func (e *ClientException) ErrorCode() string

func (*ClientException) ErrorFault 

func (e *ClientException) ErrorFault() smithy.ErrorFault

func (*ClientException) ErrorMessage 

func (e *ClientException) ErrorMessage() string

type ComputeEnvironmentDetail 

type ComputeEnvironmentDetail struct {

	// The Amazon Resource Name (ARN) of the compute environment.
	//
	// This member is required.
	ComputeEnvironmentArn *string

	// The name of the compute environment.
	//
	// This member is required.
	ComputeEnvironmentName *string

	// The Amazon Resource Name (ARN) of the underlying Amazon ECS cluster used by the
	// compute environment.
	//
	// This member is required.
	EcsClusterArn *string

	// The compute resources defined for the compute environment.
	ComputeResources *ComputeResource

	// The service role associated with the compute environment that allows AWS Batch
	// to make calls to AWS API operations on your behalf.
	ServiceRole *string

	// The state of the compute environment. The valid values are ENABLED or DISABLED.
	// If the state is ENABLED, then the AWS Batch scheduler can attempt to place jobs
	// from an associated job queue on the compute resources within the environment. If
	// the compute environment is managed, then it can scale its instances out or in
	// automatically, based on the job queue demand. If the state is DISABLED, then the
	// AWS Batch scheduler does not attempt to place jobs within the environment. Jobs
	// in a STARTING or RUNNING state continue to progress normally. Managed compute
	// environments in the DISABLED state do not scale out. However, they scale in to
	// minvCpus value after instances become idle.
	State CEState

	// The current status of the compute environment (for example, CREATING or VALID).
	Status CEStatus

	// A short, human-readable string to provide additional details about the current
	// status of the compute environment.
	StatusReason *string

	// The tags applied to the compute environment.
	Tags map[string]string

	// The type of the compute environment.
	Type CEType
}

An object representing an AWS Batch compute environment.

type ComputeEnvironmentOrder 

type ComputeEnvironmentOrder struct {

	// The Amazon Resource Name (ARN) of the compute environment.
	//
	// This member is required.
	ComputeEnvironment *string

	// The order of the compute environment.
	//
	// This member is required.
	Order int32
}

The order in which compute environments are tried for job placement within a queue. Compute environments are tried in ascending order. For example, if two compute environments are associated with a job queue, the compute environment with a lower order integer value is tried for job placement first.

type ComputeResource 

type ComputeResource struct {

	// 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:::instance-profile/ecsInstanceRole . For more information, see
	// Amazon ECS Instance Role
	// (https://docs.aws.amazon.com/batch/latest/userguide/instance_IAM_role.html) in
	// the AWS Batch User Guide.
	//
	// This member is required.
	InstanceRole *string

	// The instances types that may 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 pick instance types (from the C, M, and R instance families)
	// on the fly that match the demand of your job queues.
	//
	// This member is required.
	InstanceTypes []string

	// The maximum number of Amazon EC2 vCPUs that an environment can reach.
	//
	// This member is required.
	MaxvCpus int32

	// The minimum number of Amazon EC2 vCPUs that an environment should maintain (even
	// if the compute environment is DISABLED).
	//
	// This member is required.
	MinvCpus int32

	// The VPC subnets into which the compute resources are launched. For more
	// information, see VPCs and Subnets
	// (https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html) in the
	// Amazon VPC User Guide.
	//
	// This member is required.
	Subnets []string

	// The type of compute environment: EC2 or SPOT.
	//
	// This member is required.
	Type CRType

	// The allocation strategy to use for the compute resource in case not enough
	// instances of the best fitting instance type can be allocated. This could be due
	// to availability of the instance type in the region or Amazon EC2 service limits
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-resource-limits.html).
	// If this is not specified, the default is BEST_FIT, which will use only the best
	// fitting instance type, waiting for additional capacity if it's not available.
	// 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 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 vCPU. SPOT_CAPACITY_OPTIMIZED is only
	// available for Spot Instance compute resources and 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 that are less likely to be
	// interrupted. For more information, see Allocation Strategies
	// (https://docs.aws.amazon.com/batch/latest/userguide/allocation-strategies.html)
	// in the AWS Batch User Guide.
	AllocationStrategy CRAllocationStrategy

	// 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 below
	// 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.
	BidPercentage int32

	// The desired number of Amazon EC2 vCPUS in the compute environment.
	DesiredvCpus int32

	// The Amazon EC2 key pair that is used for instances launched in the compute
	// environment.
	Ec2KeyPair *string

	// The Amazon Machine Image (AMI) ID used for instances launched in the compute
	// environment.
	ImageId *string

	// 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 Launch Template Support
	// (https://docs.aws.amazon.com/batch/latest/userguide/launch-templates.html) in
	// the AWS Batch User Guide.
	LaunchTemplate *LaunchTemplateSpecification

	// 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 Placement Groups
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html) in
	// the Amazon EC2 User Guide for Linux Instances.
	PlacementGroup *string

	// 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. If
	// security groups are specified using both securityGroupIds and launchTemplate,
	// the values in securityGroupIds will be used.
	SecurityGroupIds []string

	// 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 is not specified. For more
	// information, see Amazon EC2 Spot Fleet Role
	// (https://docs.aws.amazon.com/batch/latest/userguide/spot_fleet_IAM_role.html) in
	// the AWS Batch User Guide.
	SpotIamFleetRole *string

	// Key-value pair tags to be applied to resources that are launched in the compute
	// environment. For AWS Batch, these take the form of "String1": "String2", where
	// String1 is the tag key and String2 is the tag value—for example, { "Name": "AWS
	// Batch Instance - C4OnDemand" }. These tags can not be updated or removed after
	// the compute environment has been created; any changes require creating a new
	// compute environment and removing the old compute environment. These tags are not
	// seen when using the AWS Batch ListTagsForResource API operation.
	Tags map[string]string
}

An object representing an AWS Batch compute resource.

type ComputeResourceUpdate 

type ComputeResourceUpdate struct {

	// The desired number of Amazon EC2 vCPUS in the compute environment.
	DesiredvCpus int32

	// The maximum number of Amazon EC2 vCPUs that an environment can reach.
	MaxvCpus int32

	// The minimum number of Amazon EC2 vCPUs that an environment should maintain.
	MinvCpus int32
}

An object representing the attributes of a compute environment that can be updated.

type ContainerDetail 

type ContainerDetail struct {

	// The command that is passed to the container.
	Command []string

	// The Amazon Resource Name (ARN) of the container instance on which the container
	// is running.
	ContainerInstanceArn *string

	// The environment variables to pass to a container. Environment variables must not
	// start with AWS_BATCH; this naming convention is reserved for variables that are
	// set by the AWS Batch service.
	Environment []KeyValuePair

	// The Amazon Resource Name (ARN) of the execution role that AWS Batch can assume.
	// For more information, see AWS Batch execution IAM role
	// (https://docs.aws.amazon.com/batch/latest/userguide/execution-IAM-role.html).
	ExecutionRoleArn *string

	// The exit code to return upon completion.
	ExitCode int32

	// The image used to start the container.
	Image *string

	// The instance type of the underlying host infrastructure of a multi-node parallel
	// job.
	InstanceType *string

	// The Amazon Resource Name (ARN) associated with the job upon execution.
	JobRoleArn *string

	// Linux-specific modifications that are applied to the container, such as details
	// for device mappings.
	LinuxParameters *LinuxParameters

	// The log configuration specification for the container. This parameter maps to
	// LogConfig in the Create a container
	// (https://docs.docker.com/engine/api/v1.23/#create-a-container) section of the
	// Docker Remote API (https://docs.docker.com/engine/api/v1.23/) and the
	// --log-driver option to docker run
	// (https://docs.docker.com/engine/reference/run/). By default, containers use the
	// same logging driver that the Docker daemon uses. However the container may use a
	// different logging driver than the Docker daemon by specifying a log driver with
	// this parameter in the container definition. To use a different logging driver
	// for a container, the log system must be configured properly on the container
	// instance (or on a different log server for remote logging options). For more
	// information on the options for different supported log drivers, see Configure
	// logging drivers (https://docs.docker.com/engine/admin/logging/overview/) in the
	// Docker documentation. AWS Batch currently supports a subset of the logging
	// drivers available to the Docker daemon (shown in the LogConfiguration data
	// type). Additional log drivers may be available in future releases of the Amazon
	// ECS container agent. This parameter requires version 1.18 of the Docker Remote
	// API or greater on your container instance. To check the Docker Remote API
	// version on your container instance, log into your container instance and run the
	// following command: sudo docker version | grep "Server API version" The Amazon
	// ECS container agent running on a container instance must register the logging
	// drivers available on that instance with the ECS_AVAILABLE_LOGGING_DRIVERS
	// environment variable before containers placed on that instance can use these log
	// configuration options. For more information, see Amazon ECS Container Agent
	// Configuration
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html)
	// in the Amazon Elastic Container Service Developer Guide.
	LogConfiguration *LogConfiguration

	// The name of the CloudWatch Logs log stream associated with the container. The
	// log group for AWS Batch jobs is /aws/batch/job. Each container attempt receives
	// a log stream name when they reach the RUNNING status.
	LogStreamName *string

	// The number of MiB of memory reserved for the job. This is a required parameter.
	Memory int32

	// The mount points for data volumes in your container.
	MountPoints []MountPoint

	// The network interfaces associated with the job.
	NetworkInterfaces []NetworkInterface

	// When this parameter is true, the container is given elevated privileges on the
	// host container instance (similar to the root user).
	Privileged bool

	// When this parameter is true, the container is given read-only access to its root
	// file system.
	ReadonlyRootFilesystem bool

	// A short (255 max characters) human-readable string to provide additional details
	// about a running or stopped container.
	Reason *string

	// The type and amount of a resource to assign to a container. Currently, the only
	// supported resource is GPU.
	ResourceRequirements []ResourceRequirement

	// The secrets to pass to the container. For more information, see Specifying
	// Sensitive Data
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html)
	// in the Amazon Elastic Container Service Developer Guide.
	Secrets []Secret

	// The Amazon Resource Name (ARN) of the Amazon ECS task that is associated with
	// the container job. Each container attempt receives a task ARN when they reach
	// the STARTING status.
	TaskArn *string

	// A list of ulimit values to set in the container.
	Ulimits []Ulimit

	// The user name to use inside the container.
	User *string

	// The number of VCPUs allocated for the job. This is a required parameter.
	Vcpus int32

	// A list of volumes associated with the job.
	Volumes []Volume
}

An object representing the details of a container that is part of a job.

type ContainerOverrides 

type ContainerOverrides struct {

	// The command to send to the container that overrides the default command from the
	// Docker image or the job definition.
	Command []string

	// The environment variables to send to the container. You can add new environment
	// variables, which are added to the container at launch, or you can override the
	// existing environment variables from the Docker image or the job definition.
	// Environment variables must not start with AWS_BATCH; this naming convention is
	// reserved for variables that are set by the AWS Batch service.
	Environment []KeyValuePair

	// The instance type to use for a multi-node parallel job. This parameter is not
	// valid for single-node container jobs.
	InstanceType *string

	// The number of MiB of memory reserved for the job. This value overrides the value
	// set in the job definition.
	Memory int32

	// The type and amount of a resource to assign to a container. This value overrides
	// the value set in the job definition. Currently, the only supported resource is
	// GPU.
	ResourceRequirements []ResourceRequirement

	// The number of vCPUs to reserve for the container. This value overrides the value
	// set in the job definition.
	Vcpus int32
}

The overrides that should be sent to a container.

type ContainerProperties 

type ContainerProperties struct {

	// The command that is passed to the container. This parameter maps to Cmd in the
	// Create a container
	// (https://docs.docker.com/engine/api/v1.23/#create-a-container) section of the
	// Docker Remote API (https://docs.docker.com/engine/api/v1.23/) and the COMMAND
	// parameter to docker run (https://docs.docker.com/engine/reference/run/). For
	// more information, see https://docs.docker.com/engine/reference/builder/#cmd
	// (https://docs.docker.com/engine/reference/builder/#cmd).
	Command []string

	// The environment variables to pass to a container. This parameter maps to Env in
	// the Create a container
	// (https://docs.docker.com/engine/api/v1.23/#create-a-container) section of the
	// Docker Remote API (https://docs.docker.com/engine/api/v1.23/) and the --env
	// option to docker run (https://docs.docker.com/engine/reference/run/). We do not
	// recommend using plaintext environment variables for sensitive information, such
	// as credential data. Environment variables must not start with AWS_BATCH; this
	// naming convention is reserved for variables that are set by the AWS Batch
	// service.
	Environment []KeyValuePair

	// The Amazon Resource Name (ARN) of the execution role that AWS Batch can assume.
	// For more information, see AWS Batch execution IAM role
	// (https://docs.aws.amazon.com/batch/latest/userguide/execution-IAM-role.html).
	ExecutionRoleArn *string

	// The image used to start a container. This string is passed directly to the
	// Docker daemon. Images in the Docker Hub registry are available by default. Other
	// repositories are specified with  repository-url/image:tag . Up to 255 letters
	// (uppercase and lowercase), numbers, hyphens, underscores, colons, periods,
	// forward slashes, and number signs are allowed. This parameter maps to Image in
	// the Create a container
	// (https://docs.docker.com/engine/api/v1.23/#create-a-container) section of the
	// Docker Remote API (https://docs.docker.com/engine/api/v1.23/) and the IMAGE
	// parameter of docker run (https://docs.docker.com/engine/reference/run/).
	//
	// *
	// Images in Amazon ECR repositories use the full registry and repository URI (for
	// example, 012345678910.dkr.ecr..amazonaws.com/).
	//
	// * Images in official
	// repositories on Docker Hub use a single name (for example, ubuntu or mongo).
	//
	// *
	// Images in other repositories on Docker Hub are qualified with an organization
	// name (for example, amazon/amazon-ecs-agent).
	//
	// * Images in other online
	// repositories are qualified further by a domain name (for example,
	// quay.io/assemblyline/ubuntu).
	Image *string

	// The instance type to use for a multi-node parallel job. Currently all node
	// groups in a multi-node parallel job must use the same instance type. This
	// parameter is not valid for single-node container jobs.
	InstanceType *string

	// The Amazon Resource Name (ARN) of the IAM role that the container can assume for
	// AWS permissions.
	JobRoleArn *string

	// Linux-specific modifications that are applied to the container, such as details
	// for device mappings.
	LinuxParameters *LinuxParameters

	// The log configuration specification for the container. This parameter maps to
	// LogConfig in the Create a container
	// (https://docs.docker.com/engine/api/v1.23/#create-a-container) section of the
	// Docker Remote API (https://docs.docker.com/engine/api/v1.23/) and the
	// --log-driver option to docker run
	// (https://docs.docker.com/engine/reference/run/). By default, containers use the
	// same logging driver that the Docker daemon uses. However the container may use a
	// different logging driver than the Docker daemon by specifying a log driver with
	// this parameter in the container definition. To use a different logging driver
	// for a container, the log system must be configured properly on the container
	// instance (or on a different log server for remote logging options). For more
	// information on the options for different supported log drivers, see Configure
	// logging drivers (https://docs.docker.com/engine/admin/logging/overview/) in the
	// Docker documentation. AWS Batch currently supports a subset of the logging
	// drivers available to the Docker daemon (shown in the LogConfiguration data
	// type). This parameter requires version 1.18 of the Docker Remote API or greater
	// on your container instance. To check the Docker Remote API version on your
	// container instance, log into your container instance and run the following
	// command: sudo docker version | grep "Server API version" The Amazon ECS
	// container agent running on a container instance must register the logging
	// drivers available on that instance with the ECS_AVAILABLE_LOGGING_DRIVERS
	// environment variable before containers placed on that instance can use these log
	// configuration options. For more information, see Amazon ECS Container Agent
	// Configuration
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html)
	// in the Amazon Elastic Container Service Developer Guide.
	LogConfiguration *LogConfiguration

	// The hard limit (in MiB) of memory to present to the container. If your container
	// attempts to exceed the memory specified here, the container is killed. This
	// parameter maps to Memory in the Create a container
	// (https://docs.docker.com/engine/api/v1.23/#create-a-container) section of the
	// Docker Remote API (https://docs.docker.com/engine/api/v1.23/) and the --memory
	// option to docker run (https://docs.docker.com/engine/reference/run/). You must
	// specify at least 4 MiB of memory for a job. This is required but can be
	// specified in several places for multi-node parallel (MNP) jobs; it must be
	// specified for each node at least once. If you are trying to maximize your
	// resource utilization by providing your jobs as much memory as possible for a
	// particular instance type, see Memory Management
	// (https://docs.aws.amazon.com/batch/latest/userguide/memory-management.html) in
	// the AWS Batch User Guide.
	Memory int32

	// The mount points for data volumes in your container. This parameter maps to
	// Volumes in the Create a container
	// (https://docs.docker.com/engine/api/v1.23/#create-a-container) section of the
	// Docker Remote API (https://docs.docker.com/engine/api/v1.23/) and the --volume
	// option to docker run (https://docs.docker.com/engine/reference/run/).
	MountPoints []MountPoint

	// When this parameter is true, the container is given elevated privileges on the
	// host container instance (similar to the root user). This parameter maps to
	// Privileged in the Create a container
	// (https://docs.docker.com/engine/api/v1.23/#create-a-container) section of the
	// Docker Remote API (https://docs.docker.com/engine/api/v1.23/) and the
	// --privileged option to docker run
	// (https://docs.docker.com/engine/reference/run/).
	Privileged bool

	// When this parameter is true, the container is given read-only access to its root
	// file system. This parameter maps to ReadonlyRootfs in the Create a container
	// (https://docs.docker.com/engine/api/v1.23/#create-a-container) section of the
	// Docker Remote API (https://docs.docker.com/engine/api/v1.23/) and the
	// --read-only option to docker run.
	ReadonlyRootFilesystem bool

	// The type and amount of a resource to assign to a container. Currently, the only
	// supported resource is GPU.
	ResourceRequirements []ResourceRequirement

	// The secrets for the container. For more information, see Specifying Sensitive
	// Data
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html)
	// in the Amazon Elastic Container Service Developer Guide.
	Secrets []Secret

	// A list of ulimits to set in the container. This parameter maps to Ulimits in the
	// Create a container
	// (https://docs.docker.com/engine/api/v1.23/#create-a-container) section of the
	// Docker Remote API (https://docs.docker.com/engine/api/v1.23/) and the --ulimit
	// option to docker run (https://docs.docker.com/engine/reference/run/).
	Ulimits []Ulimit

	// The user name to use inside the container. This parameter maps to User in the
	// Create a container
	// (https://docs.docker.com/engine/api/v1.23/#create-a-container) section of the
	// Docker Remote API (https://docs.docker.com/engine/api/v1.23/) and the --user
	// option to docker run (https://docs.docker.com/engine/reference/run/).
	User *string

	// The number of vCPUs reserved for the container. This parameter maps to CpuShares
	// in the Create a container
	// (https://docs.docker.com/engine/api/v1.23/#create-a-container) section of the
	// Docker Remote API (https://docs.docker.com/engine/api/v1.23/) and the
	// --cpu-shares option to docker run
	// (https://docs.docker.com/engine/reference/run/). Each vCPU is equivalent to
	// 1,024 CPU shares. You must specify at least one vCPU. This is required but can
	// be specified in several places for multi-node parallel (MNP) jobs; it must be
	// specified for each node at least once.
	Vcpus int32

	// A list of data volumes used in a job.
	Volumes []Volume
}

Container properties are used in job definitions to describe the container that is launched as part of a job.

type ContainerSummary 

type ContainerSummary struct {

	// The exit code to return upon completion.
	ExitCode int32

	// A short (255 max characters) human-readable string to provide additional details
	// about a running or stopped container.
	Reason *string
}

An object representing summary details of a container within a job.

type Device 

type Device struct {

	// The path for the device on the host container instance.
	//
	// This member is required.
	HostPath *string

	// The path inside the container at which to expose the host device. By default the
	// hostPath value is used.
	ContainerPath *string

	// The explicit permissions to provide to the container for the device. By default,
	// the container has permissions for read, write, and mknod for the device.
	Permissions []DeviceCgroupPermission
}

An object representing a container instance host device.

type DeviceCgroupPermission 

type DeviceCgroupPermission string
const (
	DeviceCgroupPermissionRead  DeviceCgroupPermission = "READ"
	DeviceCgroupPermissionWrite DeviceCgroupPermission = "WRITE"
	DeviceCgroupPermissionMknod DeviceCgroupPermission = "MKNOD"
)

Enum values for DeviceCgroupPermission

func (DeviceCgroupPermission) Values added in v0.29.0 

func (DeviceCgroupPermission) Values() []DeviceCgroupPermission

Values returns all known values for DeviceCgroupPermission. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

type EvaluateOnExit added in v0.29.0 

type EvaluateOnExit struct {

	// Specifies the action to take if all of the specified conditions (onStatusReason,
	// onReason, and onExitCode) are met.
	//
	// This member is required.
	Action RetryAction

	// Contains a glob pattern to match against the decimal representation of the
	// ExitCode returned for a job. The patten can be up to 512 characters long, can
	// contain only numbers, and can optionally end with an asterisk (*) so that only
	// the start of the string needs to be an exact match.
	OnExitCode *string

	// Contains a glob pattern to match against the Reason returned for a job. The
	// patten can be up to 512 characters long, can contain letters, numbers, periods
	// (.), colons (:), and whitespace (spaces, tabs), and can optionally end with an
	// asterisk (*) so that only the start of the string needs to be an exact match.
	OnReason *string

	// Contains a glob pattern to match against the StatusReason returned for a job.
	// The patten can be up to 512 characters long, can contain letters, numbers,
	// periods (.), colons (:), and whitespace (spaces, tabs). and can optionally end
	// with an asterisk (*) so that only the start of the string needs to be an exact
	// match.
	OnStatusReason *string
}

Specifies a set of conditions to be met, and an action to take (RETRY or EXIT) if all conditions are met.

type Host 

type Host struct {

	// The path on the host container instance that is presented to the container. If
	// this parameter is empty, then the Docker daemon has assigned a host path for
	// you. If this parameter contains a file location, then the data volume persists
	// at the specified location on the host container instance until you delete it
	// manually. If the source path location does not exist on the host container
	// instance, the Docker daemon creates it. If the location does exist, the contents
	// of the source path folder are exported.
	SourcePath *string
}

Determine whether your data volume persists on the host container instance and where it is stored. If this parameter is empty, then the Docker daemon assigns a host path for your data volume, but the data is not guaranteed to persist after the containers associated with it stop running.

type JQState 

type JQState string
const (
	JQStateEnabled  JQState = "ENABLED"
	JQStateDisabled JQState = "DISABLED"
)

Enum values for JQState

func (JQState) Values added in v0.29.0 

func (JQState) Values() []JQState

Values returns all known values for JQState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

type JQStatus 

type JQStatus string
const (
	JQStatusCreating JQStatus = "CREATING"
	JQStatusUpdating JQStatus = "UPDATING"
	JQStatusDeleting JQStatus = "DELETING"
	JQStatusDeleted  JQStatus = "DELETED"
	JQStatusValid    JQStatus = "VALID"
	JQStatusInvalid  JQStatus = "INVALID"
)

Enum values for JQStatus

func (JQStatus) Values added in v0.29.0 

func (JQStatus) Values() []JQStatus

Values returns all known values for JQStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

type JobDefinition 

type JobDefinition struct {

	// The Amazon Resource Name (ARN) for the job definition.
	//
	// This member is required.
	JobDefinitionArn *string

	// The name of the job definition.
	//
	// This member is required.
	JobDefinitionName *string

	// The revision of the job definition.
	//
	// This member is required.
	Revision int32

	// The type of job definition.
	//
	// This member is required.
	Type *string

	// An object with various properties specific to container-based jobs.
	ContainerProperties *ContainerProperties

	// An object with various properties specific to multi-node parallel jobs.
	NodeProperties *NodeProperties

	// Default parameters or parameter substitution placeholders that are set in the
	// job definition. Parameters are specified as a key-value pair mapping. Parameters
	// in a SubmitJob request override any corresponding parameter defaults from the
	// job definition. For more information about specifying parameters, see Job
	// Definition Parameters
	// (https://docs.aws.amazon.com/batch/latest/userguide/job_definition_parameters.html)
	// in the AWS Batch User Guide.
	Parameters map[string]string

	// The retry strategy to use for failed jobs that are submitted with this job
	// definition.
	RetryStrategy *RetryStrategy

	// The status of the job definition.
	Status *string

	// The tags applied to the job definition.
	Tags map[string]string

	// The timeout configuration for jobs that are submitted with this job definition.
	// You can specify a timeout duration after which AWS Batch terminates your jobs if
	// they have not finished.
	Timeout *JobTimeout
}

An object representing an AWS Batch job definition.

type JobDefinitionType 

type JobDefinitionType string
const (
	JobDefinitionTypeContainer JobDefinitionType = "container"
	JobDefinitionTypeMultinode JobDefinitionType = "multinode"
)

Enum values for JobDefinitionType

func (JobDefinitionType) Values added in v0.29.0 

func (JobDefinitionType) Values() []JobDefinitionType

Values returns all known values for JobDefinitionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

type JobDependency 

type JobDependency struct {

	// The job ID of the AWS Batch job associated with this dependency.
	JobId *string

	// The type of the job dependency.
	Type ArrayJobDependency
}

An object representing an AWS Batch job dependency.

type JobDetail 

type JobDetail struct {

	// The job definition that is used by this job.
	//
	// This member is required.
	JobDefinition *string

	// The ID for the job.
	//
	// This member is required.
	JobId *string

	// The name of the job.
	//
	// This member is required.
	JobName *string

	// The Amazon Resource Name (ARN) of the job queue with which the job is
	// associated.
	//
	// This member is required.
	JobQueue *string

	// The Unix timestamp (in milliseconds) for when the job was started (when the job
	// transitioned from the STARTING state to the RUNNING state). This parameter is
	// not provided for child jobs of array jobs or multi-node parallel jobs.
	//
	// This member is required.
	StartedAt int64

	// The current status for the job. If your jobs do not progress to STARTING, see
	// Jobs Stuck in RUNNABLE Status
	// (https://docs.aws.amazon.com/batch/latest/userguide/troubleshooting.html#job_stuck_in_runnable)
	// in the troubleshooting section of the AWS Batch User Guide.
	//
	// This member is required.
	Status JobStatus

	// The array properties of the job, if it is an array job.
	ArrayProperties *ArrayPropertiesDetail

	// A list of job attempts associated with this job.
	Attempts []AttemptDetail

	// An object representing the details of the container that is associated with the
	// job.
	Container *ContainerDetail

	// The Unix timestamp (in milliseconds) for when the job was created. For non-array
	// jobs and parent array jobs, this is when the job entered the SUBMITTED state (at
	// the time SubmitJob was called). For array child jobs, this is when the child job
	// was spawned by its parent and entered the PENDING state.
	CreatedAt int64

	// A list of job IDs on which this job depends.
	DependsOn []JobDependency

	// The Amazon Resource Name (ARN) of the job.
	JobArn *string

	// An object representing the details of a node that is associated with a
	// multi-node parallel job.
	NodeDetails *NodeDetails

	// An object representing the node properties of a multi-node parallel job.
	NodeProperties *NodeProperties

	// Additional parameters passed to the job that replace parameter substitution
	// placeholders or override any corresponding parameter defaults from the job
	// definition.
	Parameters map[string]string

	// The retry strategy to use for this job if an attempt fails.
	RetryStrategy *RetryStrategy

	// A short, human-readable string to provide additional details about the current
	// status of the job.
	StatusReason *string

	// The Unix timestamp (in milliseconds) for when the job was stopped (when the job
	// transitioned from the RUNNING state to a terminal state, such as SUCCEEDED or
	// FAILED).
	StoppedAt int64

	// The tags applied to the job.
	Tags map[string]string

	// The timeout configuration for the job.
	Timeout *JobTimeout
}

An object representing an AWS Batch job.

type JobQueueDetail 

type JobQueueDetail struct {

	// The compute environments that are attached to the job queue and the order in
	// which job placement is preferred. Compute environments are selected for job
	// placement in ascending order.
	//
	// This member is required.
	ComputeEnvironmentOrder []ComputeEnvironmentOrder

	// The Amazon Resource Name (ARN) of the job queue.
	//
	// This member is required.
	JobQueueArn *string

	// The name of the job queue.
	//
	// This member is required.
	JobQueueName *string

	// The priority of the job queue.
	//
	// This member is required.
	Priority int32

	// Describes the ability of the queue to accept new jobs. If the job queue state is
	// ENABLED, it is able to accept jobs. If the job queue state is DISABLED, new jobs
	// cannot be added to the queue, but jobs already in the queue can finish.
	//
	// This member is required.
	State JQState

	// The status of the job queue (for example, CREATING or VALID).
	Status JQStatus

	// A short, human-readable string to provide additional details about the current
	// status of the job queue.
	StatusReason *string

	// The tags applied to the job queue.
	Tags map[string]string
}

An object representing the details of an AWS Batch job queue.

type JobStatus 

type JobStatus string
const (
	JobStatusSubmitted JobStatus = "SUBMITTED"
	JobStatusPending   JobStatus = "PENDING"
	JobStatusRunnable  JobStatus = "RUNNABLE"
	JobStatusStarting  JobStatus = "STARTING"
	JobStatusRunning   JobStatus = "RUNNING"
	JobStatusSucceeded JobStatus = "SUCCEEDED"
	JobStatusFailed    JobStatus = "FAILED"
)

Enum values for JobStatus

func (JobStatus) Values added in v0.29.0 

func (JobStatus) Values() []JobStatus

Values returns all known values for JobStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

type JobSummary 

type JobSummary struct {

	// The ID of the job.
	//
	// This member is required.
	JobId *string

	// The name of the job.
	//
	// This member is required.
	JobName *string

	// The array properties of the job, if it is an array job.
	ArrayProperties *ArrayPropertiesSummary

	// An object representing the details of the container that is associated with the
	// job.
	Container *ContainerSummary

	// The Unix timestamp for when the job was created. For non-array jobs and parent
	// array jobs, this is when the job entered the SUBMITTED state (at the time
	// SubmitJob was called). For array child jobs, this is when the child job was
	// spawned by its parent and entered the PENDING state.
	CreatedAt int64

	// The Amazon Resource Name (ARN) of the job.
	JobArn *string

	// The node properties for a single node in a job summary list.
	NodeProperties *NodePropertiesSummary

	// The Unix timestamp for when the job was started (when the job transitioned from
	// the STARTING state to the RUNNING state).
	StartedAt int64

	// The current status for the job.
	Status JobStatus

	// A short, human-readable string to provide additional details about the current
	// status of the job.
	StatusReason *string

	// The Unix timestamp for when the job was stopped (when the job transitioned from
	// the RUNNING state to a terminal state, such as SUCCEEDED or FAILED).
	StoppedAt int64
}

An object representing summary details of a job.

type JobTimeout 

type JobTimeout struct {

	// The time duration in seconds (measured from the job attempt's startedAt
	// timestamp) after which AWS Batch terminates your jobs if they have not finished.
	AttemptDurationSeconds int32
}

An object representing a job timeout configuration.

type KeyValuePair 

type KeyValuePair struct {

	// The name of the key-value pair. For environment variables, this is the name of
	// the environment variable.
	Name *string

	// The value of the key-value pair. For environment variables, this is the value of
	// the environment variable.
	Value *string
}

A key-value pair object.

type LaunchTemplateSpecification 

type LaunchTemplateSpecification struct {

	// The ID of the launch template.
	LaunchTemplateId *string

	// The name of the launch template.
	LaunchTemplateName *string

	// The version number of the launch template, $Latest, or $Default. If the value is
	// $Latest, the latest version of the launch template is used. If the value is
	// $Default, the default version of the launch template is used. Default: $Default.
	Version *string
}

An object representing a launch template associated with a compute resource. You must specify either the launch template ID or launch template name in the request, but not both.

type LinuxParameters 

type LinuxParameters struct {

	// Any host devices to expose to the container. This parameter maps to Devices in
	// the Create a container
	// (https://docs.docker.com/engine/api/v1.23/#create-a-container) section of the
	// Docker Remote API (https://docs.docker.com/engine/api/v1.23/) and the --device
	// option to docker run (https://docs.docker.com/engine/reference/run/).
	Devices []Device

	// If true, run an init process inside the container that forwards signals and
	// reaps processes. This parameter maps to the --init option to docker run
	// (https://docs.docker.com/engine/reference/run/). This parameter requires version
	// 1.25 of the Docker Remote API or greater on your container instance. To check
	// the Docker Remote API version on your container instance, log into your
	// container instance and run the following command: sudo docker version | grep
	// "Server API version"
	InitProcessEnabled bool

	// The total amount of swap memory (in MiB) a container can use. This parameter
	// will be translated to the --memory-swap option to docker run
	// (https://docs.docker.com/engine/reference/run/) where the value would be the sum
	// of the container memory plus the maxSwap value. For more information, see
	// --memory-swap details
	// (https://docs.docker.com/config/containers/resource_constraints/#--memory-swap-details)
	// in the Docker documentation. If a maxSwap value of 0 is specified, the container
	// will not use swap. Accepted values are 0 or any positive integer. If the maxSwap
	// parameter is omitted, the container will use the swap configuration for the
	// container instance it is running on. A maxSwap value must be set for the
	// swappiness parameter to be used.
	MaxSwap int32

	// The value for the size (in MiB) of the /dev/shm volume. This parameter maps to
	// the --shm-size option to docker run
	// (https://docs.docker.com/engine/reference/run/).
	SharedMemorySize int32

	// This allows you to tune a container's memory swappiness behavior. A swappiness
	// value of 0 will cause swapping to not happen unless absolutely necessary. A
	// swappiness value of 100 will cause pages to be swapped very aggressively.
	// Accepted values are whole numbers between 0 and 100. If the swappiness parameter
	// is not specified, a default value of 60 is used. If a value is not specified for
	// maxSwap then this parameter is ignored. This parameter maps to the
	// --memory-swappiness option to docker run
	// (https://docs.docker.com/engine/reference/run/).
	Swappiness int32

	// The container path, mount options, and size (in MiB) of the tmpfs mount. This
	// parameter maps to the --tmpfs option to docker run
	// (https://docs.docker.com/engine/reference/run/).
	Tmpfs []Tmpfs
}

Linux-specific modifications that are applied to the container, such as details for device mappings.

type LogConfiguration added in v0.29.0 

type LogConfiguration struct {

	// The log driver to use for the container. The valid values listed for this
	// parameter are log drivers that the Amazon ECS container agent can communicate
	// with by default. The supported log drivers are awslogs, fluentd, gelf,
	// json-file, journald, logentries, syslog, and splunk. awslogs Specifies the
	// Amazon CloudWatch Logs logging driver. For more information, see Using the
	// awslogs Log Driver
	// (https://docs.aws.amazon.com/batch/latest/userguide/using_awslogs.html) in the
	// AWS Batch User Guide and Amazon CloudWatch Logs logging driver
	// (https://docs.docker.com/config/containers/logging/awslogs/) in the Docker
	// documentation. fluentd Specifies the Fluentd logging driver. For more
	// information, including usage and options, see Fluentd logging driver
	// (https://docs.docker.com/config/containers/logging/fluentd/) in the Docker
	// documentation. gelf Specifies the Graylog Extended Format (GELF) logging driver.
	// For more information, including usage and options, see Graylog Extended Format
	// logging driver (https://docs.docker.com/config/containers/logging/gelf/) in the
	// Docker documentation. journald Specifies the journald logging driver. For more
	// information, including usage and options, see Journald logging driver
	// (https://docs.docker.com/config/containers/logging/journald/) in the Docker
	// documentation. json-file Specifies the JSON file logging driver. For more
	// information, including usage and options, see JSON File logging driver
	// (https://docs.docker.com/config/containers/logging/json-file/) in the Docker
	// documentation. splunk Specifies the Splunk logging driver. For more information,
	// including usage and options, see Splunk logging driver
	// (https://docs.docker.com/config/containers/logging/splunk/) in the Docker
	// documentation. syslog Specifies the syslog logging driver. For more information,
	// including usage and options, see Syslog logging driver
	// (https://docs.docker.com/config/containers/logging/syslog/) in the Docker
	// documentation. If you have a custom driver that is not listed earlier that you
	// would like to work with the Amazon ECS container agent, you can fork the Amazon
	// ECS container agent project that is available on GitHub
	// (https://github.com/aws/amazon-ecs-agent) and customize it to work with that
	// driver. We encourage you to submit pull requests for changes that you would like
	// to have included. However, Amazon Web Services does not currently support
	// running modified copies of this software. This parameter requires version 1.18
	// of the Docker Remote API or greater on your container instance. To check the
	// Docker Remote API version on your container instance, log into your container
	// instance and run the following command: sudo docker version | grep "Server API
	// version"
	//
	// This member is required.
	LogDriver LogDriver

	// The configuration options to send to the log driver. This parameter requires
	// version 1.19 of the Docker Remote API or greater on your container instance. To
	// check the Docker Remote API version on your container instance, log into your
	// container instance and run the following command: sudo docker version | grep
	// "Server API version"
	Options map[string]string

	// The secrets to pass to the log configuration. For more information, see
	// Specifying Sensitive Data
	// (https://docs.aws.amazon.com/batch/latest/userguide/specifying-sensitive-data.html)
	// in the AWS Batch User Guide.
	SecretOptions []Secret
}

Log configuration options to send to a custom log driver for the container.

type LogDriver added in v0.29.0 

type LogDriver string
const (
	LogDriverJsonFile LogDriver = "json-file"
	LogDriverSyslog   LogDriver = "syslog"
	LogDriverJournald LogDriver = "journald"
	LogDriverGelf     LogDriver = "gelf"
	LogDriverFluentd  LogDriver = "fluentd"
	LogDriverAwslogs  LogDriver = "awslogs"
	LogDriverSplunk   LogDriver = "splunk"
)

Enum values for LogDriver

func (LogDriver) Values added in v0.29.0 

func (LogDriver) Values() []LogDriver

Values returns all known values for LogDriver. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

type MountPoint 

type MountPoint struct {

	// The path on the container at which to mount the host volume.
	ContainerPath *string

	// If this value is true, the container has read-only access to the volume;
	// otherwise, the container can write to the volume. The default value is false.
	ReadOnly bool

	// The name of the volume to mount.
	SourceVolume *string
}

Details on a Docker volume mount point that is used in a job's container properties. This parameter maps to Volumes in the Create a container (https://docs.docker.com/engine/reference/api/docker_remote_api_v1.19/#create-a-container) section of the Docker Remote API and the --volume option to docker run.

type NetworkInterface 

type NetworkInterface struct {

	// The attachment ID for the network interface.
	AttachmentId *string

	// The private IPv6 address for the network interface.
	Ipv6Address *string

	// The private IPv4 address for the network interface.
	PrivateIpv4Address *string
}

An object representing the elastic network interface for a multi-node parallel job node.

type NodeDetails 

type NodeDetails struct {

	// Specifies whether the current node is the main node for a multi-node parallel
	// job.
	IsMainNode bool

	// The node index for the node. Node index numbering begins at zero. This index is
	// also available on the node with the AWS_BATCH_JOB_NODE_INDEX environment
	// variable.
	NodeIndex int32
}

An object representing the details of a multi-node parallel job node.

type NodeOverrides 

type NodeOverrides struct {

	// The node property overrides for the job.
	NodePropertyOverrides []NodePropertyOverride

	// The number of nodes to use with a multi-node parallel job. This value overrides
	// the number of nodes that are specified in the job definition. To use this
	// override:
	//
	// * There must be at least one node range in your job definition that
	// has an open upper boundary (such as : or n:).
	//
	// * The lower boundary of the node
	// range specified in the job definition must be fewer than the number of nodes
	// specified in the override.
	//
	// * The main node index specified in the job
	// definition must be fewer than the number of nodes specified in the override.
	NumNodes int32
}

Object representing any node overrides to a job definition that is used in a SubmitJob API operation.

type NodeProperties 

type NodeProperties struct {

	// Specifies the node index for the main node of a multi-node parallel job. This
	// node index value must be fewer than the number of nodes.
	//
	// This member is required.
	MainNode int32

	// A list of node ranges and their properties associated with a multi-node parallel
	// job.
	//
	// This member is required.
	NodeRangeProperties []NodeRangeProperty

	// The number of nodes associated with a multi-node parallel job.
	//
	// This member is required.
	NumNodes int32
}

An object representing the node properties of a multi-node parallel job.

type NodePropertiesSummary 

type NodePropertiesSummary struct {

	// Specifies whether the current node is the main node for a multi-node parallel
	// job.
	IsMainNode bool

	// The node index for the node. Node index numbering begins at zero. This index is
	// also available on the node with the AWS_BATCH_JOB_NODE_INDEX environment
	// variable.
	NodeIndex int32

	// The number of nodes associated with a multi-node parallel job.
	NumNodes int32
}

An object representing the properties of a node that is associated with a multi-node parallel job.

type NodePropertyOverride 

type NodePropertyOverride struct {

	// The range of nodes, using node index values, with which to override. A range of
	// 0:3 indicates nodes with index values of 0 through 3. If the starting range
	// value is omitted (:n), then 0 is used to start the range. If the ending range
	// value is omitted (n:), then the highest possible node index is used to end the
	// range.
	//
	// This member is required.
	TargetNodes *string

	// The overrides that should be sent to a node range.
	ContainerOverrides *ContainerOverrides
}

Object representing any node overrides to a job definition that is used in a SubmitJob API operation.

type NodeRangeProperty 

type NodeRangeProperty struct {

	// The range of nodes, using node index values. A range of 0:3 indicates nodes with
	// index values of 0 through 3. If the starting range value is omitted (:n), then 0
	// is used to start the range. If the ending range value is omitted (n:), then the
	// highest possible node index is used to end the range. Your accumulative node
	// ranges must account for all nodes (0:n). You may nest node ranges, for example
	// 0:10 and 4:5, in which case the 4:5 range properties override the 0:10
	// properties.
	//
	// This member is required.
	TargetNodes *string

	// The container details for the node range.
	Container *ContainerProperties
}

An object representing the properties of the node range for a multi-node parallel job.

type ResourceRequirement 

type ResourceRequirement struct {

	// The type of resource to assign to a container. Currently, the only supported
	// resource type is GPU.
	//
	// This member is required.
	Type ResourceType

	// The number of physical GPUs to reserve for the container. The number of GPUs
	// reserved for all containers in a job should not exceed the number of available
	// GPUs on the compute resource that the job is launched on.
	//
	// This member is required.
	Value *string
}

The type and amount of a resource to assign to a container. Currently, the only supported resource type is GPU.

type ResourceType 

type ResourceType string
const (
	ResourceTypeGpu ResourceType = "GPU"
)

Enum values for ResourceType

func (ResourceType) Values added in v0.29.0 

func (ResourceType) Values() []ResourceType

Values returns all known values for ResourceType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

type RetryAction added in v0.29.0 

type RetryAction string
const (
	RetryActionRetry RetryAction = "RETRY"
	RetryActionExit  RetryAction = "EXIT"
)

Enum values for RetryAction

func (RetryAction) Values added in v0.29.0 

func (RetryAction) Values() []RetryAction

Values returns all known values for RetryAction. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

type RetryStrategy 

type RetryStrategy struct {

	// The number of times to move a job to the RUNNABLE status. You may specify
	// between 1 and 10 attempts. If the value of attempts is greater than one, the job
	// is retried on failure the same number of attempts as the value.
	Attempts int32

	// Array of up to 5 objects that specify conditions under which the job should be
	// retried or failed. If this parameter is specified, then the attempts parameter
	// must also be specified.
	EvaluateOnExit []EvaluateOnExit
}

The retry strategy associated with a job.

type Secret added in v0.29.0 

type Secret struct {

	// The name of the secret.
	//
	// This member is required.
	Name *string

	// The secret to expose to the container. The supported values are either the full
	// ARN of the AWS Secrets Manager secret or the full ARN of the parameter in the
	// AWS Systems Manager Parameter Store. If the AWS Systems Manager Parameter Store
	// parameter exists in the same Region as the task you are launching, then you can
	// use either the full ARN or name of the parameter. If the parameter exists in a
	// different Region, then the full ARN must be specified.
	//
	// This member is required.
	ValueFrom *string
}

An object representing the secret to expose to your container. Secrets can be exposed to a container in the following ways:

* To inject sensitive data into your containers as environment variables, use the secrets container definition parameter.

* To reference sensitive information in the log configuration of a container, use the secretOptions container definition parameter.

For more information, see Specifying Sensitive Data (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the Amazon Elastic Container Service Developer Guide.

type ServerException 

type ServerException struct {
	Message *string
}

These errors are usually caused by a server issue.

func (*ServerException) Error 

func (e *ServerException) Error() string

func (*ServerException) ErrorCode 

func (e *ServerException) ErrorCode() string

func (*ServerException) ErrorFault 

func (e *ServerException) ErrorFault() smithy.ErrorFault

func (*ServerException) ErrorMessage 

func (e *ServerException) ErrorMessage() string

type Tmpfs added in v0.29.0 

type Tmpfs struct {

	// The absolute file path in the container where the tmpfs volume is to be mounted.
	//
	// This member is required.
	ContainerPath *string

	// The size (in MiB) of the tmpfs volume.
	//
	// This member is required.
	Size int32

	// The list of tmpfs volume mount options. Valid values: "defaults" | "ro" | "rw" |
	// "suid" | "nosuid" | "dev" | "nodev" | "exec" | "noexec" | "sync" | "async" |
	// "dirsync" | "remount" | "mand" | "nomand" | "atime" | "noatime" | "diratime" |
	// "nodiratime" | "bind" | "rbind" | "unbindable" | "runbindable" | "private" |
	// "rprivate" | "shared" | "rshared" | "slave" | "rslave" | "relatime" |
	// "norelatime" | "strictatime" | "nostrictatime" | "mode" | "uid" | "gid" |
	// "nr_inodes" | "nr_blocks" | "mpol"
	MountOptions []string
}

The container path, mount options, and size of the tmpfs mount.

type Ulimit 

type Ulimit struct {

	// The hard limit for the ulimit type.
	//
	// This member is required.
	HardLimit int32

	// The type of the ulimit.
	//
	// This member is required.
	Name *string

	// The soft limit for the ulimit type.
	//
	// This member is required.
	SoftLimit int32
}

The ulimit settings to pass to the container.

type Volume 

type Volume struct {

	// The contents of the host parameter determine whether your data volume persists
	// on the host container instance and where it is stored. If the host parameter is
	// empty, then the Docker daemon assigns a host path for your data volume. However,
	// the data is not guaranteed to persist after the containers associated with it
	// stop running.
	Host *Host

	// The name of the volume. Up to 255 letters (uppercase and lowercase), numbers,
	// hyphens, and underscores are allowed. This name is referenced in the
	// sourceVolume parameter of container definition mountPoints.
	Name *string
}

A data volume used in a job's container properties.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.