types

package
v0.26.0 Latest Latest
Warning

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

 Go to latest Published: Oct 1, 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 (
	ArrayJobDependencyN_to_n     ArrayJobDependency = "N_TO_N"
	ArrayJobDependencySequential ArrayJobDependency = "SEQUENTIAL"
)

Enum values for ArrayJobDependency

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

	// 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

	// 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 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 network interfaces associated with the job attempt.
	NetworkInterfaces []*NetworkInterface

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

	// 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

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

	// 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
}

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

type AttemptDetail 

type AttemptDetail struct {

	// The Unix timestamp (in seconds and 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

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

	// The Unix timestamp (in seconds and 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

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

type CEType 

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

Enum values for CEType

type CRAllocationStrategy 

type CRAllocationStrategy string
const (
	CRAllocationStrategyBest_fit                CRAllocationStrategy = "BEST_FIT"
	CRAllocationStrategyBest_fit_progressive    CRAllocationStrategy = "BEST_FIT_PROGRESSIVE"
	CRAllocationStrategySpot_capacity_optimized CRAllocationStrategy = "SPOT_CAPACITY_OPTIMIZED"
)

Enum values for CRAllocationStrategy

type CRType 

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

Enum values for CRType

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 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 compute resources defined for the compute environment.
	ComputeResources *ComputeResource

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

	// The type of the compute environment.
	Type CEType

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

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

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

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

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

An object representing an AWS Batch compute environment.

type ComputeEnvironmentOrder 

type ComputeEnvironmentOrder struct {

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

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

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 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 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 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

	// 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 desired number of Amazon EC2 vCPUS in the compute environment.
	DesiredvCpus *int32

	// 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 maximum number of Amazon EC2 vCPUs that an environment can reach.
	//
	// This member is required.
	MaxvCpus *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 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 type of compute environment: EC2 or SPOT.
	//
	// This member is required.
	Type CRType

	// 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" }.
	Tags map[string]*string

	// 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 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 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 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
}

An object representing an AWS Batch compute resource.

type ComputeResourceUpdate 

type ComputeResourceUpdate struct {

	// 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

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

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

type ContainerDetail 

type ContainerDetail struct {

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

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

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

	// 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

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

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

	// The number of MiB of memory reserved for the job.
	Memory *int32

	// The image used to start the container.
	Image *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

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

	// 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 instance type of the underlying host infrastructure of a multi-node parallel
	// job.
	InstanceType *string

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

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

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

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

	// The number of VCPUs allocated for the job.
	Vcpus *int32

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

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

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

	// 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 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 vCPUs to reserve for the container. This value overrides the value
	// set in the job definition.
	Vcpus *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 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 number of MiB of memory reserved for the job. This value overrides the value
	// set in the job definition.
	Memory *int32
}

The overrides that should be sent to a container.

type ContainerProperties 

type ContainerProperties struct {

	// 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 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.
	Vcpus *int32

	// 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 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

	// 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 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 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

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

	// 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

	// 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

	// 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 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. 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
}

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 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

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

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

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

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

type JobDefinition 

type JobDefinition struct {

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

	// 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

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

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

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

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

	// 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 status of the job definition.
	Status *string

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

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

An object representing an AWS Batch job definition.

type JobDefinitionType 

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

Enum values for JobDefinitionType

type JobDependency 

type JobDependency struct {

	// The type of the job dependency.
	Type ArrayJobDependency

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

An object representing an AWS Batch job dependency.

type JobDetail 

type JobDetail struct {

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

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

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

	// 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

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

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

	// The Unix timestamp (in seconds and 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

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

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

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

	// The Unix timestamp (in seconds and milliseconds) for when the job was started
	// (when the job transitioned from the STARTING state to the RUNNING state).
	//
	// This member is required.
	StartedAt *int64

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

	// 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 Unix timestamp (in seconds and 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

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

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

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

An object representing an AWS Batch job.

type JobQueueDetail 

type JobQueueDetail struct {

	// Describes the ability of the queue to accept new jobs.
	//
	// This member is required.
	State JQState

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

	// 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 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 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
}

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

type JobSummary 

type JobSummary struct {

	// The current status for the job.
	Status JobStatus

	// 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

	// A short, human-readable string to provide additional details about the current
	// status of the job.
	StatusReason *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 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 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 value of the key-value pair. For environment variables, this is the value of
	// the environment variable.
	Value *string

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

A key-value pair object.

type LaunchTemplateSpecification 

type LaunchTemplateSpecification struct {

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

	// The version number of the launch template. Default: The default version of the
	// launch template.
	Version *string

	// The name of the launch template.
	LaunchTemplateName *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
}

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

type MountPoint 

type MountPoint struct {

	// 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 path on the container at which to mount the host volume.
	ContainerPath *string

	// 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 private IPv6 address for the network interface.
	Ipv6Address *string

	// The attachment ID for the network interface.
	AttachmentId *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 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

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

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

type NodeProperties 

type NodeProperties struct {

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

	// 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

	// 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 container details for the node range.
	Container *ContainerProperties

	// 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
}

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

type ResourceRequirement 

type ResourceRequirement struct {

	// 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 of resource to assign to a container. Currently, the only supported
	// resource type is GPU.
	//
	// This member is required.
	Type ResourceType
}

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

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
}

The retry strategy associated with a job.

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 Ulimit 

type Ulimit struct {

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

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

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

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.