Module types

Source
Expand description

Data structures used by operation inputs/outputs.

Modules§

builders
Builders
error
Error types that AmazonNimbleStudio can respond with.

Structs§

ActiveDirectoryComputerAttribute

An LDAP attribute of an Active Directory computer account, in the form of a name:value pair.

ActiveDirectoryConfiguration

The configuration for a Directory Service for Microsoft Active Directory studio resource.

ComputeFarmConfiguration

The configuration for a render farm that is associated with a studio resource.

Eula

Represents a EULA resource.

EulaAcceptance

The acceptance of a EULA, required to use Amazon-provided streaming images.

LaunchProfile

A launch profile controls your artist workforce’s access to studio components, like compute farms, shared file systems, managed file systems, and license server configurations, as well as instance types and Amazon Machine Images (AMIs).

Studio administrators create launch profiles in the Nimble Studio console. Artists can use their launch profiles to launch an instance from the Nimble Studio portal. Each user’s launch profile defines how they can launch a streaming session. By default, studio admins can use all launch profiles.

LaunchProfileInitialization

A launch profile initialization contains information required for a workstation or server to connect to a launch profile.

This includes scripts, endpoints, security groups, subnets, and other configuration.

LaunchProfileInitializationActiveDirectory

The launch profile initialization Active Directory contains information required for the launch profile to connect to the Active Directory.

LaunchProfileInitializationScript

The launch profile initialization script is used when start streaming session runs.

LaunchProfileMembership

Studio admins can use launch profile membership to delegate launch profile access to studio users in the Nimble Studio portal without writing or maintaining complex IAM policies. A launch profile member is a user association from your studio identity source who is granted permissions to a launch profile.

A launch profile member (type USER) provides the following permissions to that launch profile:

  • GetLaunchProfile

  • GetLaunchProfileInitialization

  • GetLaunchProfileMembers

  • GetLaunchProfileMember

  • CreateStreamingSession

  • GetLaunchProfileDetails

LicenseServiceConfiguration

The configuration for a license service that is associated with a studio resource.

NewLaunchProfileMember

A new member that is added to a launch profile.

NewStudioMember

A new studio user's membership.

ScriptParameterKeyValue

A parameter for a studio component script, in the form of a key-value pair.

SharedFileSystemConfiguration

The configuration for a shared file storage system that is associated with a studio resource.

StreamConfiguration

A configuration for a streaming session.

StreamConfigurationCreate

Configuration for streaming workstations created using this launch profile.

StreamConfigurationSessionBackup

Configures how streaming sessions are backed up when launched from this launch profile.

StreamConfigurationSessionStorage

The configuration for a streaming session’s upload storage.

StreamingImage

Represents a streaming image resource.

Streaming images are used by studio users to select which operating system and software they want to use in a Nimble Studio streaming session.

Amazon provides a number of streaming images that include popular 3rd-party software.

You can create your own streaming images using an Amazon EC2 machine image that you create for this purpose. You can also include software that your users require.

StreamingImageEncryptionConfiguration

Specifies how a streaming image is encrypted.

StreamingSession

A streaming session is a virtual workstation created using a particular launch profile.

StreamingSessionBackup

Information about the streaming session backup.

StreamingSessionStorageRoot

The upload storage root location (folder) on streaming workstations where files are uploaded.

StreamingSessionStream

A stream is an active connection to a streaming session, enabling a studio user to control the streaming session using a compatible client. Streaming session streams are compatible with the NICE DCV web client, included in the Nimble Studio portal, or the NICE DCV desktop client.

Studio

Represents a studio resource.

A studio is the core resource used with Nimble Studio. You must create a studio first, before any other resource type can be created. All other resources you create and manage in Nimble Studio are contained within a studio.

When creating a studio, you must provides two IAM roles for use with the Nimble Studio portal. These roles are assumed by your users when they log in to the Nimble Studio portal via IAM Identity Center and your identity source.

The user role must have the AmazonNimbleStudio-StudioUser managed policy attached for the portal to function properly.

The admin role must have the AmazonNimbleStudio-StudioAdmin managed policy attached for the portal to function properly.

Your studio roles must trust the identity.nimble.amazonaws.com service principal to function properly.

StudioComponent

A studio component represents a network resource to be used by a studio's users and workflows. A typical studio contains studio components for each of the following: render farm, Active Directory, licensing, and file system.

Access to a studio component is managed by specifying security groups for the resource, as well as its endpoint.

A studio component also has a set of initialization scripts that are returned by GetLaunchProfileInitialization. These initialization scripts run on streaming sessions when they start. They provide users with flexibility in controlling how the studio resources are configured on a streaming session.

StudioComponentInitializationScript

Initialization scripts for studio components.

StudioComponentSummary

The studio component's summary.

StudioEncryptionConfiguration

Configuration of the encryption method that is used for the studio.

StudioMembership

A studio member is an association of a user from your studio identity source to elevated permissions that they are granted in the studio.

When you add a user to your studio using the Nimble Studio console, they are given access to the studio's IAM Identity Center application and are given access to log in to the Nimble Studio portal. These users have the permissions provided by the studio's user IAM role and do not appear in the studio membership collection. Only studio admins appear in studio membership.

When you add a user to studio membership with the ADMIN persona, upon logging in to the Nimble Studio portal, they are granted permissions specified by the Studio's Admin IAM role.

ValidationResult

The launch profile validation result.

VolumeConfiguration

Custom volume configuration for the root volumes that are attached to streaming sessions.

This parameter is only allowed when sessionPersistenceMode is ACTIVATED.

Enums§

AutomaticTerminationMode
When writing a match expression against AutomaticTerminationMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
LaunchProfilePersona
When writing a match expression against LaunchProfilePersona, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
LaunchProfilePlatform
When writing a match expression against LaunchProfilePlatform, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
LaunchProfileState
When writing a match expression against LaunchProfileState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
LaunchProfileStatusCode
When writing a match expression against LaunchProfileStatusCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
LaunchProfileValidationState
When writing a match expression against LaunchProfileValidationState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
LaunchProfileValidationStatusCode
When writing a match expression against LaunchProfileValidationStatusCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
LaunchProfileValidationType
When writing a match expression against LaunchProfileValidationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SessionBackupMode
When writing a match expression against SessionBackupMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SessionPersistenceMode
When writing a match expression against SessionPersistenceMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StreamingClipboardMode
When writing a match expression against StreamingClipboardMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StreamingImageEncryptionConfigurationKeyType
When writing a match expression against StreamingImageEncryptionConfigurationKeyType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StreamingImageState
When writing a match expression against StreamingImageState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StreamingImageStatusCode
When writing a match expression against StreamingImageStatusCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StreamingInstanceType
When writing a match expression against StreamingInstanceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StreamingSessionState
When writing a match expression against StreamingSessionState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StreamingSessionStatusCode
When writing a match expression against StreamingSessionStatusCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StreamingSessionStorageMode
When writing a match expression against StreamingSessionStorageMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StreamingSessionStreamState
When writing a match expression against StreamingSessionStreamState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StreamingSessionStreamStatusCode
When writing a match expression against StreamingSessionStreamStatusCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StudioComponentConfiguration

The configuration of the studio component, based on component type.

StudioComponentInitializationScriptRunContext
When writing a match expression against StudioComponentInitializationScriptRunContext, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StudioComponentState
When writing a match expression against StudioComponentState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StudioComponentStatusCode
When writing a match expression against StudioComponentStatusCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StudioComponentSubtype
When writing a match expression against StudioComponentSubtype, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StudioComponentType
When writing a match expression against StudioComponentType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StudioEncryptionConfigurationKeyType
When writing a match expression against StudioEncryptionConfigurationKeyType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StudioPersona
When writing a match expression against StudioPersona, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StudioState
When writing a match expression against StudioState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StudioStatusCode
When writing a match expression against StudioStatusCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
VolumeRetentionMode
When writing a match expression against VolumeRetentionMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.