Class: Aws::Finspace::Client

Inherits:
Seahorse::Client::Base
  • Object
show all
Includes:
ClientStubs
Defined in:
lib/aws-sdk-finspace/client.rb

Overview

An API client for Finspace. To construct a client, you need to configure a ‘:region` and `:credentials`.

client = Aws::Finspace::Client.new(
  region: region_name,
  credentials: credentials,
  # ...
)

For details on configuring region and credentials see the [developer guide](/sdk-for-ruby/v3/developer-guide/setup-config.html).

See #initialize for a full list of supported configuration options.

Class Attribute Summary collapse

API Operations collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options) ⇒ Client

Returns a new instance of Client.

Parameters:

  • options (Hash)

Options Hash (options):

  • :plugins (Array<Seahorse::Client::Plugin>) — default: []] —

    A list of plugins to apply to the client. Each plugin is either a class name or an instance of a plugin class.

  • :credentials (required, Aws::CredentialProvider) —

    Your AWS credentials. This can be an instance of any one of the following classes:

    • ‘Aws::Credentials` - Used for configuring static, non-refreshing credentials.

    • ‘Aws::SharedCredentials` - Used for loading static credentials from a shared file, such as `~/.aws/config`.

    • ‘Aws::AssumeRoleCredentials` - Used when you need to assume a role.

    • ‘Aws::AssumeRoleWebIdentityCredentials` - Used when you need to assume a role after providing credentials via the web.

    • ‘Aws::SSOCredentials` - Used for loading credentials from AWS SSO using an access token generated from `aws login`.

    • ‘Aws::ProcessCredentials` - Used for loading credentials from a process that outputs to stdout.

    • ‘Aws::InstanceProfileCredentials` - Used for loading credentials from an EC2 IMDS on an EC2 instance.

    • ‘Aws::ECSCredentials` - Used for loading credentials from instances running in ECS.

    • ‘Aws::CognitoIdentityCredentials` - Used for loading credentials from the Cognito Identity service.

    When ‘:credentials` are not configured directly, the following locations will be searched for credentials:

    • ‘Aws.config`

    • The ‘:access_key_id`, `:secret_access_key`, `:session_token`, and `:account_id` options.

    • ENV, ENV, ENV, and ENV

    • ‘~/.aws/credentials`

    • ‘~/.aws/config`

    • EC2/ECS IMDS instance profile - When used by default, the timeouts are very aggressive. Construct and pass an instance of ‘Aws::InstanceProfileCredentials` or `Aws::ECSCredentials` to enable retries and extended timeouts. Instance profile credential fetching can be disabled by setting ENV to true.

  • :region (required, String) —

    The AWS region to connect to. The configured ‘:region` is used to determine the service `:endpoint`. When not passed, a default `:region` is searched for in the following locations:

  • :access_key_id (String)
  • :account_id (String)
  • :active_endpoint_cache (Boolean) — default: false —

    When set to ‘true`, a thread polling for endpoints will be running in the background every 60 secs (default). Defaults to `false`.

  • :adaptive_retry_wait_to_fill (Boolean) — default: true —

    Used only in ‘adaptive` retry mode. When true, the request will sleep until there is sufficent client side capacity to retry the request. When false, the request will raise a `RetryCapacityNotAvailableError` and will not retry instead of sleeping.

  • :client_side_monitoring (Boolean) — default: false —

    When ‘true`, client-side metrics will be collected for all API requests from this client.

  • :client_side_monitoring_client_id (String) — default: "" —

    Allows you to provide an identifier for this client which will be attached to all generated client side metrics. Defaults to an empty string.

  • :client_side_monitoring_host (String) — default: "127.0.0.1" —

    Allows you to specify the DNS hostname or IPv4 or IPv6 address that the client side monitoring agent is running on, where client metrics will be published via UDP.

  • :client_side_monitoring_port (Integer) — default: 31000 —

    Required for publishing client metrics. The port that the client side monitoring agent is running on, where client metrics will be published via UDP.

  • :client_side_monitoring_publisher (Aws::ClientSideMonitoring::Publisher) — default: Aws::ClientSideMonitoring::Publisher —

    Allows you to provide a custom client-side monitoring publisher class. By default, will use the Client Side Monitoring Agent Publisher.

  • :convert_params (Boolean) — default: true —

    When ‘true`, an attempt is made to coerce request parameters into the required types.

  • :correct_clock_skew (Boolean) — default: true —

    Used only in ‘standard` and adaptive retry modes. Specifies whether to apply a clock skew correction and retry requests with skewed client clocks.

  • :defaults_mode (String) — default: "legacy" —

    See DefaultsModeConfiguration for a list of the accepted modes and the configuration defaults that are included.

  • :disable_host_prefix_injection (Boolean) — default: false —

    Set to true to disable SDK automatically adding host prefix to default service endpoint when available.

  • :disable_request_compression (Boolean) — default: false —

    When set to ‘true’ the request body will not be compressed for supported operations.

  • :endpoint (String, URI::HTTPS, URI::HTTP) —

    Normally you should not configure the ‘:endpoint` option directly. This is normally constructed from the `:region` option. Configuring `:endpoint` is normally reserved for connecting to test or custom endpoints. The endpoint should be a URI formatted like:

    'http://example.com'
'https://example.com'
'http://example.com:123'
  • :endpoint_cache_max_entries (Integer) — default: 1000 —

    Used for the maximum size limit of the LRU cache storing endpoints data for endpoint discovery enabled operations. Defaults to 1000.

  • :endpoint_cache_max_threads (Integer) — default: 10 —

    Used for the maximum threads in use for polling endpoints to be cached, defaults to 10.

  • :endpoint_cache_poll_interval (Integer) — default: 60 —

    When :endpoint_discovery and :active_endpoint_cache is enabled, Use this option to config the time interval in seconds for making requests fetching endpoints information. Defaults to 60 sec.

  • :endpoint_discovery (Boolean) — default: false —

    When set to ‘true`, endpoint discovery will be enabled for operations when available.

  • :ignore_configured_endpoint_urls (Boolean) —

    Setting to true disables use of endpoint URLs provided via environment variables and the shared configuration file.

  • :log_formatter (Aws::Log::Formatter) — default: Aws::Log::Formatter.default —

    The log formatter.

  • :log_level (Symbol) — default: :info —

    The log level to send messages to the ‘:logger` at.

  • :logger (Logger) —

    The Logger instance to send log messages to. If this option is not set, logging will be disabled.

  • :max_attempts (Integer) — default: 3 —

    An integer representing the maximum number attempts that will be made for a single request, including the initial attempt. For example, setting this value to 5 will result in a request being retried up to 4 times. Used in ‘standard` and `adaptive` retry modes.

  • :profile (String) — default: "default" —

    Used when loading credentials from the shared credentials file at HOME/.aws/credentials. When not specified, ‘default’ is used.

  • :request_min_compression_size_bytes (Integer) — default: 10240 —

    The minimum size in bytes that triggers compression for request bodies. The value must be non-negative integer value between 0 and 10485780 bytes inclusive.

  • :retry_backoff (Proc) —

    A proc or lambda used for backoff. Defaults to 2**retries * retry_base_delay. This option is only used in the ‘legacy` retry mode.

  • :retry_base_delay (Float) — default: 0.3 —

    The base delay in seconds used by the default backoff function. This option is only used in the ‘legacy` retry mode.

  • :retry_jitter (Symbol) — default: :none —

    A delay randomiser function used by the default backoff function. Some predefined functions can be referenced by name - :none, :equal, :full, otherwise a Proc that takes and returns a number. This option is only used in the ‘legacy` retry mode.

    @see www.awsarchitectureblog.com/2015/03/backoff.html

  • :retry_limit (Integer) — default: 3 —

    The maximum number of times to retry failed requests. Only ~ 500 level server errors and certain ~ 400 level client errors are retried. Generally, these are throttling errors, data checksum errors, networking errors, timeout errors, auth errors, endpoint discovery, and errors from expired credentials. This option is only used in the ‘legacy` retry mode.

  • :retry_max_delay (Integer) — default: 0 —

    The maximum number of seconds to delay between retries (0 for no limit) used by the default backoff function. This option is only used in the ‘legacy` retry mode.

  • :retry_mode (String) — default: "legacy" —

    Specifies which retry algorithm to use. Values are:

    • ‘legacy` - The pre-existing retry behavior. This is default value if no retry mode is provided.

    • ‘standard` - A standardized set of retry rules across the AWS SDKs. This includes support for retry quotas, which limit the number of unsuccessful retries a client can make.

    • ‘adaptive` - An experimental retry mode that includes all the functionality of `standard` mode along with automatic client side throttling. This is a provisional mode that may change behavior in the future.

  • :sdk_ua_app_id (String) —

    A unique and opaque application ID that is appended to the User-Agent header as app/sdk_ua_app_id. It should have a maximum length of 50. This variable is sourced from environment variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.

  • :secret_access_key (String)
  • :session_token (String)
  • :sigv4a_signing_region_set (Array) —

    A list of regions that should be signed with SigV4a signing. When not passed, a default ‘:sigv4a_signing_region_set` is searched for in the following locations:

  • :stub_responses (Boolean) — default: false —

    Causes the client to return stubbed responses. By default fake responses are generated and returned. You can specify the response data to return or errors to raise by calling ClientStubs#stub_responses. See ClientStubs for more information.

    ** Please note ** When response stubbing is enabled, no HTTP requests are made, and retries are disabled.

  • :telemetry_provider (Aws::Telemetry::TelemetryProviderBase) — default: Aws::Telemetry::NoOpTelemetryProvider —

    Allows you to provide a telemetry provider, which is used to emit telemetry data. By default, uses ‘NoOpTelemetryProvider` which will not record or emit any telemetry data. The SDK supports the following telemetry providers:

    • OpenTelemetry (OTel) - To use the OTel provider, install and require the

    ‘opentelemetry-sdk` gem and then, pass in an instance of a `Aws::Telemetry::OTelProvider` for telemetry provider.

  • :token_provider (Aws::TokenProvider) —

    A Bearer Token Provider. This can be an instance of any one of the following classes:

    • ‘Aws::StaticTokenProvider` - Used for configuring static, non-refreshing tokens.

    • ‘Aws::SSOTokenProvider` - Used for loading tokens from AWS SSO using an access token generated from `aws login`.

    When ‘:token_provider` is not configured directly, the `Aws::TokenProviderChain` will be used to search for tokens configured for your profile in shared configuration files.

  • :use_dualstack_endpoint (Boolean) —

    When set to ‘true`, dualstack enabled endpoints (with `.aws` TLD) will be used if available.

  • :use_fips_endpoint (Boolean) —

    When set to ‘true`, fips compatible endpoints will be used if available. When a `fips` region is used, the region is normalized and this config is set to `true`.

  • :validate_params (Boolean) — default: true —

    When ‘true`, request parameters are validated before sending the request.

  • :endpoint_provider (Aws::Finspace::EndpointProvider) —

    The endpoint provider used to resolve endpoints. Any object that responds to ‘#resolve_endpoint(parameters)` where `parameters` is a Struct similar to `Aws::Finspace::EndpointParameters`.

  • :http_continue_timeout (Float) — default: 1 —

    The number of seconds to wait for a 100-continue response before sending the request body. This option has no effect unless the request has “Expect” header set to “100-continue”. Defaults to ‘nil` which disables this behaviour. This value can safely be set per request on the session.

  • :http_idle_timeout (Float) — default: 5 —

    The number of seconds a connection is allowed to sit idle before it is considered stale. Stale connections are closed and removed from the pool before making a request.

  • :http_open_timeout (Float) — default: 15 —

    The default number of seconds to wait for response data. This value can safely be set per-request on the session.

  • :http_proxy (URI::HTTP, String) —

    A proxy to send requests through. Formatted like ‘proxy.com:123’.

  • :http_read_timeout (Float) — default: 60 —

    The default number of seconds to wait for response data. This value can safely be set per-request on the session.

  • :http_wire_trace (Boolean) — default: false —

    When ‘true`, HTTP debug output will be sent to the `:logger`.

  • :on_chunk_received (Proc) —

    When a Proc object is provided, it will be used as callback when each chunk of the response body is received. It provides three arguments: the chunk, the number of bytes received, and the total number of bytes in the response (or nil if the server did not send a ‘content-length`).

  • :on_chunk_sent (Proc) —

    When a Proc object is provided, it will be used as callback when each chunk of the request body is sent. It provides three arguments: the chunk, the number of bytes read from the body, and the total number of bytes in the body.

  • :raise_response_errors (Boolean) — default: true —

    When ‘true`, response errors are raised.

  • :ssl_ca_bundle (String) —

    Full path to the SSL certificate authority bundle file that should be used when verifying peer certificates. If you do not pass ‘:ssl_ca_bundle` or `:ssl_ca_directory` the the system default will be used if available.

  • :ssl_ca_directory (String) —

    Full path of the directory that contains the unbundled SSL certificate authority files for verifying peer certificates. If you do not pass ‘:ssl_ca_bundle` or `:ssl_ca_directory` the the system default will be used if available.

  • :ssl_ca_store (String) —

    Sets the X509::Store to verify peer certificate.

  • :ssl_cert (OpenSSL::X509::Certificate) —

    Sets a client certificate when creating http connections.

  • :ssl_key (OpenSSL::PKey) —

    Sets a client key when creating http connections.

  • :ssl_timeout (Float) —

    Sets the SSL timeout in seconds

  • :ssl_verify_peer (Boolean) — default: true —

    When ‘true`, SSL peer certificates are verified when establishing a connection.



446
447
448
 
# File 'lib/aws-sdk-finspace/client.rb', line 446

def initialize(*args)
  super
end

Class Attribute Details

.identifier ⇒ Object (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



3811
3812
3813
 
# File 'lib/aws-sdk-finspace/client.rb', line 3811

def identifier
  @identifier
end

Class Method Details

.errors_module ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



3814
3815
3816
 
# File 'lib/aws-sdk-finspace/client.rb', line 3814

def errors_module
  Errors
end

Instance Method Details

#build_request(operation_name, params = {}) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Parameters:

  • params ({}) (defaults to: {}) 


3784
3785
3786
3787
3788
3789
3790
3791
3792
3793
3794
3795
3796
3797
3798
3799
3800
 
# File 'lib/aws-sdk-finspace/client.rb', line 3784

def build_request(operation_name, params = {})
  handlers = @handlers.for(operation_name)
  tracer = config.telemetry_provider.tracer_provider.tracer(
    Aws::Telemetry.module_to_tracer_name('Aws::Finspace')
  )
  context = Seahorse::Client::RequestContext.new(
    operation_name: operation_name,
    operation: config.api.operation(operation_name),
    client: self,
    params: params,
    config: config,
    tracer: tracer
  )
  context[:gem_name] = 'aws-sdk-finspace'
  context[:gem_version] = '1.47.0'
  Seahorse::Client::Request.new(handlers, context)
end

#create_environment(params = {}) ⇒ Types::CreateEnvironmentResponse

Create a new FinSpace environment.

Examples:

Request syntax with placeholder values


resp = client.create_environment({
  name: "EnvironmentName", # required
  description: "Description",
  kms_key_id: "KmsKeyId",
  tags: {
    "TagKey" => "TagValue",
  },
  federation_mode: "FEDERATED", # accepts FEDERATED, LOCAL
  federation_parameters: {
    saml_metadata_document: "SamlMetadataDocument",
    saml_metadata_url: "url",
    application_call_back_url: "url",
    federation_urn: "urn",
    federation_provider_name: "FederationProviderName",
    attribute_map: {
      "FederationAttributeKey" => "FederationAttributeValue",
    },
  },
  superuser_parameters: {
    email_address: "EmailId", # required
    first_name: "NameString", # required
    last_name: "NameString", # required
  },
  data_bundles: ["DataBundleArn"],
})

Response structure


resp.environment_id #=> String
resp.environment_arn #=> String
resp.environment_url #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :name (required, String) —

    The name of the FinSpace environment to be created.

  • :description (String) —

    The description of the FinSpace environment to be created.

  • :kms_key_id (String) —

    The KMS key id to encrypt your data in the FinSpace environment.

  • :tags (Hash<String,String>) —

    Add tags to your FinSpace environment.

  • :federation_mode (String) —

    Authentication mode for the environment.

    • ‘FEDERATED` - Users access FinSpace through Single Sign On (SSO) via your Identity provider.

    • ‘LOCAL` - Users access FinSpace via email and password managed within the FinSpace environment.

  • :federation_parameters (Types::FederationParameters) —

    Configuration information when authentication mode is FEDERATED.

  • :superuser_parameters (Types::SuperuserParameters) —

    Configuration information for the superuser.

  • :data_bundles (Array<String>) —

    The list of Amazon Resource Names (ARN) of the data bundles to install. Currently supported data bundle ARNs:

    • ‘arn:aws:finspace:$Region::data-bundle/capital-markets-sample` - Contains sample Capital Markets datasets, categories and controlled vocabularies.

    • ‘arn:aws:finspace:$Region::data-bundle/taq` (default) - Contains trades and quotes data in addition to sample Capital Markets data.

Returns:

See Also:



536
537
538
539
 
# File 'lib/aws-sdk-finspace/client.rb', line 536

def create_environment(params = {}, options = {})
  req = build_request(:create_environment, params)
  req.send_request(options)
end

#create_kx_changeset(params = {}) ⇒ Types::CreateKxChangesetResponse

Creates a changeset for a kdb database. A changeset allows you to add and delete existing files by using an ordered list of change requests.

Examples:

Request syntax with placeholder values


resp = client.create_kx_changeset({
  environment_id: "EnvironmentId", # required
  database_name: "DatabaseName", # required
  change_requests: [ # required
    {
      change_type: "PUT", # required, accepts PUT, DELETE
      s3_path: "S3Path",
      db_path: "DbPath", # required
    },
  ],
  client_token: "ClientTokenString", # required
})

Response structure


resp.changeset_id #=> String
resp.database_name #=> String
resp.environment_id #=> String
resp.change_requests #=> Array
resp.change_requests[0].change_type #=> String, one of "PUT", "DELETE"
resp.change_requests[0].s3_path #=> String
resp.change_requests[0].db_path #=> String
resp.created_timestamp #=> Time
resp.last_modified_timestamp #=> Time
resp.status #=> String, one of "PENDING", "PROCESSING", "FAILED", "COMPLETED"
resp.error_info.error_message #=> String
resp.error_info.error_type #=> String, one of "The inputs to this request are invalid.", "Service limits have been exceeded.", "Missing required permission to perform this request.", "One or more inputs to this request were not found.", "The system temporarily lacks sufficient resources to process the request.", "An internal error has occurred.", "Cancelled", "A user recoverable error has occurred"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier of the kdb environment.

  • :database_name (required, String) —

    The name of the kdb database.

  • :change_requests (required, Array<Types::ChangeRequest>) —

    A list of change request objects that are run in order. A change request object consists of ‘changeType` , `s3Path`, and `dbPath`. A changeType can have the following values:

    • PUT – Adds or updates files in a database.

    • DELETE – Deletes files in a database.

    All the change requests require a mandatory ‘dbPath` attribute that defines the path within the database directory. All database paths must start with a leading / and end with a trailing /. The `s3Path` attribute defines the s3 source file path and is required for a PUT change type. The `s3path` must end with a trailing / if it is a directory and must end without a trailing / if it is a file.

    Here are few examples of how you can use the change request object:

    1. This request adds a single sym file at database root location.

      ‘{ “changeType”: “PUT”, “s3Path”:“s3://bucket/db/sym”, “dbPath”:“/”}`

    2. This request adds files in the given ‘s3Path` under the 2020.01.02 partition of the database.

      ‘{ “changeType”: “PUT”, “s3Path”:“s3://bucket/db/2020.01.02/”, “dbPath”:“/2020.01.02/”}`

    3. This request adds files in the given ‘s3Path` under the taq table partition of the database.

      ‘[ { “changeType”: “PUT”, “s3Path”:“s3://bucket/db/2020.01.02/taq/”, “dbPath”:“/2020.01.02/taq/”}]`

    4. This request deletes the 2020.01.02 partition of the database.

      ‘[{ “changeType”: “DELETE”, “dbPath”: “/2020.01.02/”} ]`

    5. The DELETE request allows you to delete the existing files under the 2020.01.02 partition of the database, and the PUT request adds a new taq table under it.

      ‘[ “DELETE”, “dbPath”:“/2020.01.02/”, “PUT”, “s3Path”:“s3://bucket/db/2020.01.02/taq/”, “dbPath”:“/2020.01.02/taq/”]`

  • :client_token (required, String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

See Also:



649
650
651
652
 
# File 'lib/aws-sdk-finspace/client.rb', line 649

def create_kx_changeset(params = {}, options = {})
  req = build_request(:create_kx_changeset, params)
  req.send_request(options)
end

#create_kx_cluster(params = {}) ⇒ Types::CreateKxClusterResponse

Creates a new kdb cluster.

Examples:

Request syntax with placeholder values


resp = client.create_kx_cluster({
  client_token: "ClientToken",
  environment_id: "KxEnvironmentId", # required
  cluster_name: "KxClusterName", # required
  cluster_type: "HDB", # required, accepts HDB, RDB, GATEWAY, GP, TICKERPLANT
  tickerplant_log_configuration: {
    tickerplant_log_volumes: ["VolumeName"],
  },
  databases: [
    {
      database_name: "DatabaseName", # required
      cache_configurations: [
        {
          cache_type: "KxCacheStorageType", # required
          db_paths: ["DbPath"], # required
          dataview_name: "KxDataviewName",
        },
      ],
      changeset_id: "ChangesetId",
      dataview_name: "KxDataviewName",
      dataview_configuration: {
        dataview_name: "KxDataviewName",
        dataview_version_id: "VersionId",
        changeset_id: "ChangesetId",
        segment_configurations: [
          {
            db_paths: ["DbPath"], # required
            volume_name: "KxVolumeName", # required
            on_demand: false,
          },
        ],
      },
    },
  ],
  cache_storage_configurations: [
    {
      type: "KxCacheStorageType", # required
      size: 1, # required
    },
  ],
  auto_scaling_configuration: {
    min_node_count: 1,
    max_node_count: 1,
    auto_scaling_metric: "CPU_UTILIZATION_PERCENTAGE", # accepts CPU_UTILIZATION_PERCENTAGE
    metric_target: 1.0,
    scale_in_cooldown_seconds: 1.0,
    scale_out_cooldown_seconds: 1.0,
  },
  cluster_description: "KxClusterDescription",
  capacity_configuration: {
    node_type: "NodeType",
    node_count: 1,
  },
  release_label: "ReleaseLabel", # required
  vpc_configuration: { # required
    vpc_id: "VpcIdString",
    security_group_ids: ["SecurityGroupIdString"],
    subnet_ids: ["SubnetIdString"],
    ip_address_type: "IP_V4", # accepts IP_V4
  },
  initialization_script: "InitializationScriptFilePath",
  command_line_arguments: [
    {
      key: "KxCommandLineArgumentKey",
      value: "KxCommandLineArgumentValue",
    },
  ],
  code: {
    s3_bucket: "S3Bucket",
    s3_key: "S3Key",
    s3_object_version: "S3ObjectVersion",
  },
  execution_role: "ExecutionRoleArn",
  savedown_storage_configuration: {
    type: "SDS01", # accepts SDS01
    size: 1,
    volume_name: "KxVolumeName",
  },
  az_mode: "SINGLE", # required, accepts SINGLE, MULTI
  availability_zone_id: "AvailabilityZoneId",
  tags: {
    "TagKey" => "TagValue",
  },
  scaling_group_configuration: {
    scaling_group_name: "KxScalingGroupName", # required
    memory_limit: 1,
    memory_reservation: 1, # required
    node_count: 1, # required
    cpu: 1.0,
  },
})

Response structure


resp.environment_id #=> String
resp.status #=> String, one of "PENDING", "CREATING", "CREATE_FAILED", "RUNNING", "UPDATING", "DELETING", "DELETED", "DELETE_FAILED"
resp.status_reason #=> String
resp.cluster_name #=> String
resp.cluster_type #=> String, one of "HDB", "RDB", "GATEWAY", "GP", "TICKERPLANT"
resp.tickerplant_log_configuration.tickerplant_log_volumes #=> Array
resp.tickerplant_log_configuration.tickerplant_log_volumes[0] #=> String
resp.volumes #=> Array
resp.volumes[0].volume_name #=> String
resp.volumes[0].volume_type #=> String, one of "NAS_1"
resp.databases #=> Array
resp.databases[0].database_name #=> String
resp.databases[0].cache_configurations #=> Array
resp.databases[0].cache_configurations[0].cache_type #=> String
resp.databases[0].cache_configurations[0].db_paths #=> Array
resp.databases[0].cache_configurations[0].db_paths[0] #=> String
resp.databases[0].cache_configurations[0].dataview_name #=> String
resp.databases[0].changeset_id #=> String
resp.databases[0].dataview_name #=> String
resp.databases[0].dataview_configuration.dataview_name #=> String
resp.databases[0].dataview_configuration.dataview_version_id #=> String
resp.databases[0].dataview_configuration.changeset_id #=> String
resp.databases[0].dataview_configuration.segment_configurations #=> Array
resp.databases[0].dataview_configuration.segment_configurations[0].db_paths #=> Array
resp.databases[0].dataview_configuration.segment_configurations[0].db_paths[0] #=> String
resp.databases[0].dataview_configuration.segment_configurations[0].volume_name #=> String
resp.databases[0].dataview_configuration.segment_configurations[0].on_demand #=> Boolean
resp.cache_storage_configurations #=> Array
resp.cache_storage_configurations[0].type #=> String
resp.cache_storage_configurations[0].size #=> Integer
resp.auto_scaling_configuration.min_node_count #=> Integer
resp.auto_scaling_configuration.max_node_count #=> Integer
resp.auto_scaling_configuration.auto_scaling_metric #=> String, one of "CPU_UTILIZATION_PERCENTAGE"
resp.auto_scaling_configuration.metric_target #=> Float
resp.auto_scaling_configuration.scale_in_cooldown_seconds #=> Float
resp.auto_scaling_configuration.scale_out_cooldown_seconds #=> Float
resp.cluster_description #=> String
resp.capacity_configuration.node_type #=> String
resp.capacity_configuration.node_count #=> Integer
resp.release_label #=> String
resp.vpc_configuration.vpc_id #=> String
resp.vpc_configuration.security_group_ids #=> Array
resp.vpc_configuration.security_group_ids[0] #=> String
resp.vpc_configuration.subnet_ids #=> Array
resp.vpc_configuration.subnet_ids[0] #=> String
resp.vpc_configuration.ip_address_type #=> String, one of "IP_V4"
resp.initialization_script #=> String
resp.command_line_arguments #=> Array
resp.command_line_arguments[0].key #=> String
resp.command_line_arguments[0].value #=> String
resp.code.s3_bucket #=> String
resp.code.s3_key #=> String
resp.code.s3_object_version #=> String
resp.execution_role #=> String
resp.last_modified_timestamp #=> Time
resp.savedown_storage_configuration.type #=> String, one of "SDS01"
resp.savedown_storage_configuration.size #=> Integer
resp.savedown_storage_configuration.volume_name #=> String
resp.az_mode #=> String, one of "SINGLE", "MULTI"
resp.availability_zone_id #=> String
resp.created_timestamp #=> Time
resp.scaling_group_configuration.scaling_group_name #=> String
resp.scaling_group_configuration.memory_limit #=> Integer
resp.scaling_group_configuration.memory_reservation #=> Integer
resp.scaling_group_configuration.node_count #=> Integer
resp.scaling_group_configuration.cpu #=> Float

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :client_token (String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :cluster_name (required, String) —

    A unique name for the cluster that you want to create.

  • :cluster_type (required, String) —

    Specifies the type of KDB database that is being created. The following types are available:

    • HDB – A Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed kdb databases mounted to the cluster.

    • RDB – A Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the ‘savedownStorageConfiguration` parameter.

    • GATEWAY – A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.

    • GP – A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only ‘SINGLE` AZ mode.

    • Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.

  • :tickerplant_log_configuration (Types::TickerplantLogConfiguration) —

    A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type ‘Tickerplant`, the location of the TP volume on the cluster will be available by using the global variable `.aws.tp_log_path`.

  • :databases (Array<Types::KxDatabaseConfiguration>) —

    A list of databases that will be available for querying.

  • :cache_storage_configurations (Array<Types::KxCacheStorageConfiguration>) —

    The configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store.

  • :auto_scaling_configuration (Types::AutoScalingConfiguration) —

    The configuration based on which FinSpace will scale in or scale out nodes in your cluster.

  • :cluster_description (String) —

    A description of the cluster.

  • :capacity_configuration (Types::CapacityConfiguration) —

    A structure for the metadata of a cluster. It includes information like the CPUs needed, memory of instances, and number of instances.

  • :release_label (required, String) —

    The version of FinSpace managed kdb to run.

  • :vpc_configuration (required, Types::VpcConfiguration) —

    Configuration details about the network where the Privatelink endpoint of the cluster resides.

  • :initialization_script (String) —

    Specifies a Q program that will be run at launch of a cluster. It is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, ‘somedir/init.q`.

  • :command_line_arguments (Array<Types::KxCommandLineArgument>) —

    Defines the key-value pairs to make them available inside the cluster.

  • :code (Types::CodeConfiguration) —

    The details of the custom code that you want to use inside a cluster when analyzing a data. It consists of the S3 source bucket, location, S3 object version, and the relative path from where the custom code is loaded into the cluster.

  • :execution_role (String) —

    An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.

  • :savedown_storage_configuration (Types::KxSavedownStorageConfiguration) —

    The size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose ‘clusterType` as RDB. All the data written to this storage space is lost when the cluster node is restarted.

  • :az_mode (required, String) —

    The number of availability zones you want to assign per cluster. This can be one of the following

    • ‘SINGLE` – Assigns one availability zone per cluster.

    • ‘MULTI` – Assigns all the availability zones per cluster.

  • :availability_zone_id (String) —

    The availability zone identifiers for the requested regions.

  • :tags (Hash<String,String>) —

    A list of key-value pairs to label the cluster. You can add up to 50 tags to a cluster.

  • :scaling_group_configuration (Types::KxScalingGroupConfiguration) —

    The structure that stores the configuration details of a scaling group.

Returns:

See Also:



973
974
975
976
 
# File 'lib/aws-sdk-finspace/client.rb', line 973

def create_kx_cluster(params = {}, options = {})
  req = build_request(:create_kx_cluster, params)
  req.send_request(options)
end

#create_kx_database(params = {}) ⇒ Types::CreateKxDatabaseResponse

Creates a new kdb database in the environment.

Examples:

Request syntax with placeholder values


resp = client.create_kx_database({
  environment_id: "EnvironmentId", # required
  database_name: "DatabaseName", # required
  description: "Description",
  tags: {
    "TagKey" => "TagValue",
  },
  client_token: "ClientTokenString", # required
})

Response structure


resp.database_name #=> String
resp.database_arn #=> String
resp.environment_id #=> String
resp.description #=> String
resp.created_timestamp #=> Time
resp.last_modified_timestamp #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :database_name (required, String) —

    The name of the kdb database.

  • :description (String) —

    A description of the database.

  • :tags (Hash<String,String>) —

    A list of key-value pairs to label the kdb database. You can add up to 50 tags to your kdb database

  • :client_token (required, String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

See Also:



1033
1034
1035
1036
 
# File 'lib/aws-sdk-finspace/client.rb', line 1033

def create_kx_database(params = {}, options = {})
  req = build_request(:create_kx_database, params)
  req.send_request(options)
end

#create_kx_dataview(params = {}) ⇒ Types::CreateKxDataviewResponse

Creates a snapshot of kdb database with tiered storage capabilities and a pre-warmed cache, ready for mounting on kdb clusters. Dataviews are only available for clusters running on a scaling group. They are not supported on dedicated clusters.

Examples:

Request syntax with placeholder values


resp = client.create_kx_dataview({
  environment_id: "EnvironmentId", # required
  database_name: "DatabaseName", # required
  dataview_name: "KxDataviewName", # required
  az_mode: "SINGLE", # required, accepts SINGLE, MULTI
  availability_zone_id: "AvailabilityZoneId",
  changeset_id: "ChangesetId",
  segment_configurations: [
    {
      db_paths: ["DbPath"], # required
      volume_name: "KxVolumeName", # required
      on_demand: false,
    },
  ],
  auto_update: false,
  read_write: false,
  description: "Description",
  tags: {
    "TagKey" => "TagValue",
  },
  client_token: "ClientTokenString", # required
})

Response structure


resp.dataview_name #=> String
resp.database_name #=> String
resp.environment_id #=> String
resp.az_mode #=> String, one of "SINGLE", "MULTI"
resp.availability_zone_id #=> String
resp.changeset_id #=> String
resp.segment_configurations #=> Array
resp.segment_configurations[0].db_paths #=> Array
resp.segment_configurations[0].db_paths[0] #=> String
resp.segment_configurations[0].volume_name #=> String
resp.segment_configurations[0].on_demand #=> Boolean
resp.description #=> String
resp.auto_update #=> Boolean
resp.read_write #=> Boolean
resp.created_timestamp #=> Time
resp.last_modified_timestamp #=> Time
resp.status #=> String, one of "CREATING", "ACTIVE", "UPDATING", "FAILED", "DELETING"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment, where you want to create the dataview.

  • :database_name (required, String) —

    The name of the database where you want to create a dataview.

  • :dataview_name (required, String) —

    A unique identifier for the dataview.

  • :az_mode (required, String) —

    The number of availability zones you want to assign per volume. Currently, FinSpace only supports ‘SINGLE` for volumes. This places dataview in a single AZ.

  • :availability_zone_id (String) —

    The identifier of the availability zones.

  • :changeset_id (String) —

    A unique identifier of the changeset that you want to use to ingest data.

  • :segment_configurations (Array<Types::KxDataviewSegmentConfiguration>) —

    The configuration that contains the database path of the data that you want to place on each selected volume. Each segment must have a unique database path for each volume. If you do not explicitly specify any database path for a volume, they are accessible from the cluster through the default S3/object store segment.

  • :auto_update (Boolean) —

    The option to specify whether you want to apply all the future additions and corrections automatically to the dataview, when you ingest new changesets. The default value is false.

  • :read_write (Boolean) —

    The option to specify whether you want to make the dataview writable to perform database maintenance. The following are some considerations related to writable dataviews.



    • You cannot create partial writable dataviews. When you create writeable dataviews you must provide the entire database path.

    • You cannot perform updates on a writeable dataview. Hence, ‘autoUpdate` must be set as False if `readWrite` is True for a dataview.

    • You must also use a unique volume for creating a writeable dataview. So, if you choose a volume that is already in use by another dataview, the dataview creation fails.

    • Once you create a dataview as writeable, you cannot change it to read-only. So, you cannot update the ‘readWrite` parameter later.

  • :description (String) —

    A description of the dataview.

  • :tags (Hash<String,String>) —

    A list of key-value pairs to label the dataview. You can add up to 50 tags to a dataview.

  • :client_token (required, String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

See Also:



1174
1175
1176
1177
 
# File 'lib/aws-sdk-finspace/client.rb', line 1174

def create_kx_dataview(params = {}, options = {})
  req = build_request(:create_kx_dataview, params)
  req.send_request(options)
end

#create_kx_environment(params = {}) ⇒ Types::CreateKxEnvironmentResponse

Creates a managed kdb environment for the account.

Examples:

Request syntax with placeholder values


resp = client.create_kx_environment({
  name: "KxEnvironmentName", # required
  description: "Description",
  kms_key_id: "KmsKeyARN", # required
  tags: {
    "TagKey" => "TagValue",
  },
  client_token: "ClientToken",
})

Response structure


resp.name #=> String
resp.status #=> String, one of "CREATE_REQUESTED", "CREATING", "CREATED", "DELETE_REQUESTED", "DELETING", "DELETED", "FAILED_CREATION", "RETRY_DELETION", "FAILED_DELETION", "UPDATE_NETWORK_REQUESTED", "UPDATING_NETWORK", "FAILED_UPDATING_NETWORK", "SUSPENDED"
resp.environment_id #=> String
resp.description #=> String
resp.environment_arn #=> String
resp.kms_key_id #=> String
resp.creation_timestamp #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :name (required, String) —

    The name of the kdb environment that you want to create.

  • :description (String) —

    A description for the kdb environment.

  • :kms_key_id (required, String) —

    The KMS key ID to encrypt your data in the FinSpace environment.

  • :tags (Hash<String,String>) —

    A list of key-value pairs to label the kdb environment. You can add up to 50 tags to your kdb environment.

  • :client_token (String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

See Also:



1236
1237
1238
1239
 
# File 'lib/aws-sdk-finspace/client.rb', line 1236

def create_kx_environment(params = {}, options = {})
  req = build_request(:create_kx_environment, params)
  req.send_request(options)
end

#create_kx_scaling_group(params = {}) ⇒ Types::CreateKxScalingGroupResponse

Creates a new scaling group.

Examples:

Request syntax with placeholder values


resp = client.create_kx_scaling_group({
  client_token: "ClientToken", # required
  environment_id: "KxEnvironmentId", # required
  scaling_group_name: "KxScalingGroupName", # required
  host_type: "KxHostType", # required
  availability_zone_id: "AvailabilityZoneId", # required
  tags: {
    "TagKey" => "TagValue",
  },
})

Response structure


resp.environment_id #=> String
resp.scaling_group_name #=> String
resp.host_type #=> String
resp.availability_zone_id #=> String
resp.status #=> String, one of "CREATING", "CREATE_FAILED", "ACTIVE", "DELETING", "DELETED", "DELETE_FAILED"
resp.last_modified_timestamp #=> Time
resp.created_timestamp #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :client_token (required, String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :environment_id (required, String) —

    A unique identifier for the kdb environment, where you want to create the scaling group.

  • :scaling_group_name (required, String) —

    A unique identifier for the kdb scaling group.

  • :host_type (required, String) —

    The memory and CPU capabilities of the scaling group host on which FinSpace Managed kdb clusters will be placed.

    You can add one of the following values:

    • ‘kx.sg.large` – The host type with a configuration of 16 GiB memory and 2 vCPUs.

    • ‘kx.sg.xlarge` – The host type with a configuration of 32 GiB memory and 4 vCPUs.

    • ‘kx.sg.2xlarge` – The host type with a configuration of 64 GiB memory and 8 vCPUs.

    • ‘kx.sg.4xlarge` – The host type with a configuration of 108 GiB memory and 16 vCPUs.

    • ‘kx.sg.8xlarge` – The host type with a configuration of 216 GiB memory and 32 vCPUs.

    • ‘kx.sg.16xlarge` – The host type with a configuration of 432 GiB memory and 64 vCPUs.

    • ‘kx.sg.32xlarge` – The host type with a configuration of 864 GiB memory and 128 vCPUs.

    • ‘kx.sg1.16xlarge` – The host type with a configuration of 1949 GiB memory and 64 vCPUs.

    • ‘kx.sg1.24xlarge` – The host type with a configuration of 2948 GiB memory and 96 vCPUs.

  • :availability_zone_id (required, String) —

    The identifier of the availability zones.

  • :tags (Hash<String,String>) —

    A list of key-value pairs to label the scaling group. You can add up to 50 tags to a scaling group.

Returns:

See Also:



1333
1334
1335
1336
 
# File 'lib/aws-sdk-finspace/client.rb', line 1333

def create_kx_scaling_group(params = {}, options = {})
  req = build_request(:create_kx_scaling_group, params)
  req.send_request(options)
end

#create_kx_user(params = {}) ⇒ Types::CreateKxUserResponse

Creates a user in FinSpace kdb environment with an associated IAM role.

Examples:

Request syntax with placeholder values


resp = client.create_kx_user({
  environment_id: "IdType", # required
  user_name: "KxUserNameString", # required
  iam_role: "RoleArn", # required
  tags: {
    "TagKey" => "TagValue",
  },
  client_token: "ClientToken",
})

Response structure


resp.user_name #=> String
resp.user_arn #=> String
resp.environment_id #=> String
resp.iam_role #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment where you want to create a user.

  • :user_name (required, String) —

    A unique identifier for the user.

  • :iam_role (required, String) —

    The IAM role ARN that will be associated with the user.

  • :tags (Hash<String,String>) —

    A list of key-value pairs to label the user. You can add up to 50 tags to a user.

  • :client_token (String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

See Also:



1391
1392
1393
1394
 
# File 'lib/aws-sdk-finspace/client.rb', line 1391

def create_kx_user(params = {}, options = {})
  req = build_request(:create_kx_user, params)
  req.send_request(options)
end

#create_kx_volume(params = {}) ⇒ Types::CreateKxVolumeResponse

Creates a new volume with a specific amount of throughput and storage capacity.

Examples:

Request syntax with placeholder values


resp = client.create_kx_volume({
  client_token: "ClientToken",
  environment_id: "KxEnvironmentId", # required
  volume_type: "NAS_1", # required, accepts NAS_1
  volume_name: "KxVolumeName", # required
  description: "Description",
  nas1_configuration: {
    type: "SSD_1000", # accepts SSD_1000, SSD_250, HDD_12
    size: 1,
  },
  az_mode: "SINGLE", # required, accepts SINGLE, MULTI
  availability_zone_ids: ["AvailabilityZoneId"], # required
  tags: {
    "TagKey" => "TagValue",
  },
})

Response structure


resp.environment_id #=> String
resp.volume_name #=> String
resp.volume_type #=> String, one of "NAS_1"
resp.volume_arn #=> String
resp.nas1_configuration.type #=> String, one of "SSD_1000", "SSD_250", "HDD_12"
resp.nas1_configuration.size #=> Integer
resp.status #=> String, one of "CREATING", "CREATE_FAILED", "ACTIVE", "UPDATING", "UPDATED", "UPDATE_FAILED", "DELETING", "DELETED", "DELETE_FAILED"
resp.status_reason #=> String
resp.az_mode #=> String, one of "SINGLE", "MULTI"
resp.description #=> String
resp.availability_zone_ids #=> Array
resp.availability_zone_ids[0] #=> String
resp.created_timestamp #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :client_token (String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :environment_id (required, String) —

    A unique identifier for the kdb environment, whose clusters can attach to the volume.

  • :volume_type (required, String) —

    The type of file system volume. Currently, FinSpace only supports ‘NAS_1` volume type. When you select `NAS_1` volume type, you must also provide `nas1Configuration`.

  • :volume_name (required, String) —

    A unique identifier for the volume.

  • :description (String) —

    A description of the volume.

  • :nas1_configuration (Types::KxNAS1Configuration) —

    Specifies the configuration for the Network attached storage (NAS_1) file system volume. This parameter is required when you choose ‘volumeType` as NAS_1.

  • :az_mode (required, String) —

    The number of availability zones you want to assign per volume. Currently, FinSpace only supports ‘SINGLE` for volumes. This places dataview in a single AZ.

  • :availability_zone_ids (required, Array<String>) —

    The identifier of the availability zones.

  • :tags (Hash<String,String>) —

    A list of key-value pairs to label the volume. You can add up to 50 tags to a volume.

Returns:

See Also:



1490
1491
1492
1493
 
# File 'lib/aws-sdk-finspace/client.rb', line 1490

def create_kx_volume(params = {}, options = {})
  req = build_request(:create_kx_volume, params)
  req.send_request(options)
end

#delete_environment(params = {}) ⇒ Struct

Delete an FinSpace environment.

Examples:

Request syntax with placeholder values


resp = client.delete_environment({
  environment_id: "IdType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    The identifier for the FinSpace environment.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1512
1513
1514
1515
 
# File 'lib/aws-sdk-finspace/client.rb', line 1512

def delete_environment(params = {}, options = {})
  req = build_request(:delete_environment, params)
  req.send_request(options)
end

#delete_kx_cluster(params = {}) ⇒ Struct

Deletes a kdb cluster.

Examples:

Request syntax with placeholder values


resp = client.delete_kx_cluster({
  environment_id: "KxEnvironmentId", # required
  cluster_name: "KxClusterName", # required
  client_token: "ClientTokenString",
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :cluster_name (required, String) —

    The name of the cluster that you want to delete.

  • :client_token (String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1545
1546
1547
1548
 
# File 'lib/aws-sdk-finspace/client.rb', line 1545

def delete_kx_cluster(params = {}, options = {})
  req = build_request(:delete_kx_cluster, params)
  req.send_request(options)
end

#delete_kx_cluster_node(params = {}) ⇒ Struct

Deletes the specified nodes from a cluster.

Examples:

Request syntax with placeholder values


resp = client.delete_kx_cluster_node({
  environment_id: "KxEnvironmentId", # required
  cluster_name: "KxClusterName", # required
  node_id: "KxClusterNodeIdString", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :cluster_name (required, String) —

    The name of the cluster, for which you want to delete the nodes.

  • :node_id (required, String) —

    A unique identifier for the node that you want to delete.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1575
1576
1577
1578
 
# File 'lib/aws-sdk-finspace/client.rb', line 1575

def delete_kx_cluster_node(params = {}, options = {})
  req = build_request(:delete_kx_cluster_node, params)
  req.send_request(options)
end

#delete_kx_database(params = {}) ⇒ Struct

Deletes the specified database and all of its associated data. This action is irreversible. You must copy any data out of the database before deleting it if the data is to be retained.

Examples:

Request syntax with placeholder values


resp = client.delete_kx_database({
  environment_id: "EnvironmentId", # required
  database_name: "DatabaseName", # required
  client_token: "ClientTokenString", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :database_name (required, String) —

    The name of the kdb database that you want to delete.

  • :client_token (required, String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1610
1611
1612
1613
 
# File 'lib/aws-sdk-finspace/client.rb', line 1610

def delete_kx_database(params = {}, options = {})
  req = build_request(:delete_kx_database, params)
  req.send_request(options)
end

#delete_kx_dataview(params = {}) ⇒ Struct

Deletes the specified dataview. Before deleting a dataview, make sure that it is not in use by any cluster.

Examples:

Request syntax with placeholder values


resp = client.delete_kx_dataview({
  environment_id: "EnvironmentId", # required
  database_name: "DatabaseName", # required
  dataview_name: "KxDataviewName", # required
  client_token: "ClientTokenString", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment, from where you want to delete the dataview.

  • :database_name (required, String) —

    The name of the database whose dataview you want to delete.

  • :dataview_name (required, String) —

    The name of the dataview that you want to delete.

  • :client_token (required, String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1649
1650
1651
1652
 
# File 'lib/aws-sdk-finspace/client.rb', line 1649

def delete_kx_dataview(params = {}, options = {})
  req = build_request(:delete_kx_dataview, params)
  req.send_request(options)
end

#delete_kx_environment(params = {}) ⇒ Struct

Deletes the kdb environment. This action is irreversible. Deleting a kdb environment will remove all the associated data and any services running in it.

Examples:

Request syntax with placeholder values


resp = client.delete_kx_environment({
  environment_id: "IdType", # required
  client_token: "ClientToken",
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :client_token (String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1680
1681
1682
1683
 
# File 'lib/aws-sdk-finspace/client.rb', line 1680

def delete_kx_environment(params = {}, options = {})
  req = build_request(:delete_kx_environment, params)
  req.send_request(options)
end

#delete_kx_scaling_group(params = {}) ⇒ Struct

Deletes the specified scaling group. This action is irreversible. You cannot delete a scaling group until all the clusters running on it have been deleted.

Examples:

Request syntax with placeholder values


resp = client.delete_kx_scaling_group({
  environment_id: "KxEnvironmentId", # required
  scaling_group_name: "KxScalingGroupName", # required
  client_token: "ClientTokenString",
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment, from where you want to delete the dataview.

  • :scaling_group_name (required, String) —

    A unique identifier for the kdb scaling group.

  • :client_token (String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1716
1717
1718
1719
 
# File 'lib/aws-sdk-finspace/client.rb', line 1716

def delete_kx_scaling_group(params = {}, options = {})
  req = build_request(:delete_kx_scaling_group, params)
  req.send_request(options)
end

#delete_kx_user(params = {}) ⇒ Struct

Deletes a user in the specified kdb environment.

Examples:

Request syntax with placeholder values


resp = client.delete_kx_user({
  user_name: "KxUserNameString", # required
  environment_id: "IdType", # required
  client_token: "ClientToken",
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    A unique identifier for the user that you want to delete.

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :client_token (String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1749
1750
1751
1752
 
# File 'lib/aws-sdk-finspace/client.rb', line 1749

def delete_kx_user(params = {}, options = {})
  req = build_request(:delete_kx_user, params)
  req.send_request(options)
end

#delete_kx_volume(params = {}) ⇒ Struct

Deletes a volume. You can only delete a volume if it’s not attached to a cluster or a dataview. When a volume is deleted, any data on the volume is lost. This action is irreversible.

Examples:

Request syntax with placeholder values


resp = client.delete_kx_volume({
  environment_id: "KxEnvironmentId", # required
  volume_name: "KxVolumeName", # required
  client_token: "ClientTokenString",
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment, whose clusters can attach to the volume.

  • :volume_name (required, String) —

    The name of the volume that you want to delete.

  • :client_token (String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1785
1786
1787
1788
 
# File 'lib/aws-sdk-finspace/client.rb', line 1785

def delete_kx_volume(params = {}, options = {})
  req = build_request(:delete_kx_volume, params)
  req.send_request(options)
end

#get_environment(params = {}) ⇒ Types::GetEnvironmentResponse

Returns the FinSpace environment object.

Examples:

Request syntax with placeholder values


resp = client.get_environment({
  environment_id: "IdType", # required
})

Response structure


resp.environment.name #=> String
resp.environment.environment_id #=> String
resp.environment. #=> String
resp.environment.status #=> String, one of "CREATE_REQUESTED", "CREATING", "CREATED", "DELETE_REQUESTED", "DELETING", "DELETED", "FAILED_CREATION", "RETRY_DELETION", "FAILED_DELETION", "UPDATE_NETWORK_REQUESTED", "UPDATING_NETWORK", "FAILED_UPDATING_NETWORK", "SUSPENDED"
resp.environment.environment_url #=> String
resp.environment.description #=> String
resp.environment.environment_arn #=> String
resp.environment.sage_maker_studio_domain_url #=> String
resp.environment.kms_key_id #=> String
resp.environment. #=> String
resp.environment.federation_mode #=> String, one of "FEDERATED", "LOCAL"
resp.environment.federation_parameters.saml_metadata_document #=> String
resp.environment.federation_parameters.saml_metadata_url #=> String
resp.environment.federation_parameters.application_call_back_url #=> String
resp.environment.federation_parameters.federation_urn #=> String
resp.environment.federation_parameters.federation_provider_name #=> String
resp.environment.federation_parameters.attribute_map #=> Hash
resp.environment.federation_parameters.attribute_map["FederationAttributeKey"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    The identifier of the FinSpace environment.

Returns:

See Also:



1830
1831
1832
1833
 
# File 'lib/aws-sdk-finspace/client.rb', line 1830

def get_environment(params = {}, options = {})
  req = build_request(:get_environment, params)
  req.send_request(options)
end

#get_kx_changeset(params = {}) ⇒ Types::GetKxChangesetResponse

Returns information about a kdb changeset.

Examples:

Request syntax with placeholder values


resp = client.get_kx_changeset({
  environment_id: "EnvironmentId", # required
  database_name: "DatabaseName", # required
  changeset_id: "ChangesetId", # required
})

Response structure


resp.changeset_id #=> String
resp.database_name #=> String
resp.environment_id #=> String
resp.change_requests #=> Array
resp.change_requests[0].change_type #=> String, one of "PUT", "DELETE"
resp.change_requests[0].s3_path #=> String
resp.change_requests[0].db_path #=> String
resp.created_timestamp #=> Time
resp.active_from_timestamp #=> Time
resp.last_modified_timestamp #=> Time
resp.status #=> String, one of "PENDING", "PROCESSING", "FAILED", "COMPLETED"
resp.error_info.error_message #=> String
resp.error_info.error_type #=> String, one of "The inputs to this request are invalid.", "Service limits have been exceeded.", "Missing required permission to perform this request.", "One or more inputs to this request were not found.", "The system temporarily lacks sufficient resources to process the request.", "An internal error has occurred.", "Cancelled", "A user recoverable error has occurred"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :database_name (required, String) —

    The name of the kdb database.

  • :changeset_id (required, String) —

    A unique identifier of the changeset for which you want to retrieve data.

Returns:

See Also:



1887
1888
1889
1890
 
# File 'lib/aws-sdk-finspace/client.rb', line 1887

def get_kx_changeset(params = {}, options = {})
  req = build_request(:get_kx_changeset, params)
  req.send_request(options)
end

#get_kx_cluster(params = {}) ⇒ Types::GetKxClusterResponse

Retrieves information about a kdb cluster.

Examples:

Request syntax with placeholder values


resp = client.get_kx_cluster({
  environment_id: "KxEnvironmentId", # required
  cluster_name: "KxClusterName", # required
})

Response structure


resp.status #=> String, one of "PENDING", "CREATING", "CREATE_FAILED", "RUNNING", "UPDATING", "DELETING", "DELETED", "DELETE_FAILED"
resp.status_reason #=> String
resp.cluster_name #=> String
resp.cluster_type #=> String, one of "HDB", "RDB", "GATEWAY", "GP", "TICKERPLANT"
resp.tickerplant_log_configuration.tickerplant_log_volumes #=> Array
resp.tickerplant_log_configuration.tickerplant_log_volumes[0] #=> String
resp.volumes #=> Array
resp.volumes[0].volume_name #=> String
resp.volumes[0].volume_type #=> String, one of "NAS_1"
resp.databases #=> Array
resp.databases[0].database_name #=> String
resp.databases[0].cache_configurations #=> Array
resp.databases[0].cache_configurations[0].cache_type #=> String
resp.databases[0].cache_configurations[0].db_paths #=> Array
resp.databases[0].cache_configurations[0].db_paths[0] #=> String
resp.databases[0].cache_configurations[0].dataview_name #=> String
resp.databases[0].changeset_id #=> String
resp.databases[0].dataview_name #=> String
resp.databases[0].dataview_configuration.dataview_name #=> String
resp.databases[0].dataview_configuration.dataview_version_id #=> String
resp.databases[0].dataview_configuration.changeset_id #=> String
resp.databases[0].dataview_configuration.segment_configurations #=> Array
resp.databases[0].dataview_configuration.segment_configurations[0].db_paths #=> Array
resp.databases[0].dataview_configuration.segment_configurations[0].db_paths[0] #=> String
resp.databases[0].dataview_configuration.segment_configurations[0].volume_name #=> String
resp.databases[0].dataview_configuration.segment_configurations[0].on_demand #=> Boolean
resp.cache_storage_configurations #=> Array
resp.cache_storage_configurations[0].type #=> String
resp.cache_storage_configurations[0].size #=> Integer
resp.auto_scaling_configuration.min_node_count #=> Integer
resp.auto_scaling_configuration.max_node_count #=> Integer
resp.auto_scaling_configuration.auto_scaling_metric #=> String, one of "CPU_UTILIZATION_PERCENTAGE"
resp.auto_scaling_configuration.metric_target #=> Float
resp.auto_scaling_configuration.scale_in_cooldown_seconds #=> Float
resp.auto_scaling_configuration.scale_out_cooldown_seconds #=> Float
resp.cluster_description #=> String
resp.capacity_configuration.node_type #=> String
resp.capacity_configuration.node_count #=> Integer
resp.release_label #=> String
resp.vpc_configuration.vpc_id #=> String
resp.vpc_configuration.security_group_ids #=> Array
resp.vpc_configuration.security_group_ids[0] #=> String
resp.vpc_configuration.subnet_ids #=> Array
resp.vpc_configuration.subnet_ids[0] #=> String
resp.vpc_configuration.ip_address_type #=> String, one of "IP_V4"
resp.initialization_script #=> String
resp.command_line_arguments #=> Array
resp.command_line_arguments[0].key #=> String
resp.command_line_arguments[0].value #=> String
resp.code.s3_bucket #=> String
resp.code.s3_key #=> String
resp.code.s3_object_version #=> String
resp.execution_role #=> String
resp.last_modified_timestamp #=> Time
resp.savedown_storage_configuration.type #=> String, one of "SDS01"
resp.savedown_storage_configuration.size #=> Integer
resp.savedown_storage_configuration.volume_name #=> String
resp.az_mode #=> String, one of "SINGLE", "MULTI"
resp.availability_zone_id #=> String
resp.created_timestamp #=> Time
resp.scaling_group_configuration.scaling_group_name #=> String
resp.scaling_group_configuration.memory_limit #=> Integer
resp.scaling_group_configuration.memory_reservation #=> Integer
resp.scaling_group_configuration.node_count #=> Integer
resp.scaling_group_configuration.cpu #=> Float

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :cluster_name (required, String) —

    The name of the cluster that you want to retrieve.

Returns:

See Also:



2005
2006
2007
2008
 
# File 'lib/aws-sdk-finspace/client.rb', line 2005

def get_kx_cluster(params = {}, options = {})
  req = build_request(:get_kx_cluster, params)
  req.send_request(options)
end

#get_kx_connection_string(params = {}) ⇒ Types::GetKxConnectionStringResponse

Retrieves a connection string for a user to connect to a kdb cluster. You must call this API using the same role that you have defined while creating a user.

Examples:

Request syntax with placeholder values


resp = client.get_kx_connection_string({
  user_arn: "KxUserArn", # required
  environment_id: "IdType", # required
  cluster_name: "KxClusterName", # required
})

Response structure


resp.signed_connection_string #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_arn (required, String) —

    The Amazon Resource Name (ARN) that identifies the user. For more information about ARNs and how to use ARNs in policies, see [IAM Identifiers] in the *IAM User Guide*.

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :cluster_name (required, String) —

    A name of the kdb cluster.

Returns:

See Also:



2049
2050
2051
2052
 
# File 'lib/aws-sdk-finspace/client.rb', line 2049

def get_kx_connection_string(params = {}, options = {})
  req = build_request(:get_kx_connection_string, params)
  req.send_request(options)
end

#get_kx_database(params = {}) ⇒ Types::GetKxDatabaseResponse

Returns database information for the specified environment ID.

Examples:

Request syntax with placeholder values


resp = client.get_kx_database({
  environment_id: "EnvironmentId", # required
  database_name: "DatabaseName", # required
})

Response structure


resp.database_name #=> String
resp.database_arn #=> String
resp.environment_id #=> String
resp.description #=> String
resp.created_timestamp #=> Time
resp.last_modified_timestamp #=> Time
resp.last_completed_changeset_id #=> String
resp.num_bytes #=> Integer
resp.num_changesets #=> Integer
resp.num_files #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :database_name (required, String) —

    The name of the kdb database.

Returns:

See Also:



2099
2100
2101
2102
 
# File 'lib/aws-sdk-finspace/client.rb', line 2099

def get_kx_database(params = {}, options = {})
  req = build_request(:get_kx_database, params)
  req.send_request(options)
end

#get_kx_dataview(params = {}) ⇒ Types::GetKxDataviewResponse

Retrieves details of the dataview.

Examples:

Request syntax with placeholder values


resp = client.get_kx_dataview({
  environment_id: "EnvironmentId", # required
  database_name: "DatabaseName", # required
  dataview_name: "KxDataviewName", # required
})

Response structure


resp.database_name #=> String
resp.dataview_name #=> String
resp.az_mode #=> String, one of "SINGLE", "MULTI"
resp.availability_zone_id #=> String
resp.changeset_id #=> String
resp.segment_configurations #=> Array
resp.segment_configurations[0].db_paths #=> Array
resp.segment_configurations[0].db_paths[0] #=> String
resp.segment_configurations[0].volume_name #=> String
resp.segment_configurations[0].on_demand #=> Boolean
resp.active_versions #=> Array
resp.active_versions[0].changeset_id #=> String
resp.active_versions[0].segment_configurations #=> Array
resp.active_versions[0].segment_configurations[0].db_paths #=> Array
resp.active_versions[0].segment_configurations[0].db_paths[0] #=> String
resp.active_versions[0].segment_configurations[0].volume_name #=> String
resp.active_versions[0].segment_configurations[0].on_demand #=> Boolean
resp.active_versions[0].attached_clusters #=> Array
resp.active_versions[0].attached_clusters[0] #=> String
resp.active_versions[0].created_timestamp #=> Time
resp.active_versions[0].version_id #=> String
resp.description #=> String
resp.auto_update #=> Boolean
resp.read_write #=> Boolean
resp.environment_id #=> String
resp.created_timestamp #=> Time
resp.last_modified_timestamp #=> Time
resp.status #=> String, one of "CREATING", "ACTIVE", "UPDATING", "FAILED", "DELETING"
resp.status_reason #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment, from where you want to retrieve the dataview details.

  • :database_name (required, String) —

    The name of the database where you created the dataview.

  • :dataview_name (required, String) —

    A unique identifier for the dataview.

Returns:

See Also:



2178
2179
2180
2181
 
# File 'lib/aws-sdk-finspace/client.rb', line 2178

def get_kx_dataview(params = {}, options = {})
  req = build_request(:get_kx_dataview, params)
  req.send_request(options)
end

#get_kx_environment(params = {}) ⇒ Types::GetKxEnvironmentResponse

Retrieves all the information for the specified kdb environment.

Examples:

Request syntax with placeholder values


resp = client.get_kx_environment({
  environment_id: "IdType", # required
})

Response structure


resp.name #=> String
resp.environment_id #=> String
resp. #=> String
resp.status #=> String, one of "CREATE_REQUESTED", "CREATING", "CREATED", "DELETE_REQUESTED", "DELETING", "DELETED", "FAILED_CREATION", "RETRY_DELETION", "FAILED_DELETION", "UPDATE_NETWORK_REQUESTED", "UPDATING_NETWORK", "FAILED_UPDATING_NETWORK", "SUSPENDED"
resp.tgw_status #=> String, one of "NONE", "UPDATE_REQUESTED", "UPDATING", "FAILED_UPDATE", "SUCCESSFULLY_UPDATED"
resp.dns_status #=> String, one of "NONE", "UPDATE_REQUESTED", "UPDATING", "FAILED_UPDATE", "SUCCESSFULLY_UPDATED"
resp.error_message #=> String
resp.description #=> String
resp.environment_arn #=> String
resp.kms_key_id #=> String
resp. #=> String
resp.transit_gateway_configuration.transit_gateway_id #=> String
resp.transit_gateway_configuration.routable_cidr_space #=> String
resp.transit_gateway_configuration.attachment_network_acl_configuration #=> Array
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].rule_number #=> Integer
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].protocol #=> String
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].rule_action #=> String, one of "allow", "deny"
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].port_range.from #=> Integer
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].port_range.to #=> Integer
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].icmp_type_code.type #=> Integer
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].icmp_type_code.code #=> Integer
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].cidr_block #=> String
resp.custom_dns_configuration #=> Array
resp.custom_dns_configuration[0].custom_dns_server_name #=> String
resp.custom_dns_configuration[0].custom_dns_server_ip #=> String
resp.creation_timestamp #=> Time
resp.update_timestamp #=> Time
resp.availability_zone_ids #=> Array
resp.availability_zone_ids[0] #=> String
resp.certificate_authority_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

Returns:

See Also:



2251
2252
2253
2254
 
# File 'lib/aws-sdk-finspace/client.rb', line 2251

def get_kx_environment(params = {}, options = {})
  req = build_request(:get_kx_environment, params)
  req.send_request(options)
end

#get_kx_scaling_group(params = {}) ⇒ Types::GetKxScalingGroupResponse

Retrieves details of a scaling group.

Examples:

Request syntax with placeholder values


resp = client.get_kx_scaling_group({
  environment_id: "KxEnvironmentId", # required
  scaling_group_name: "KxScalingGroupName", # required
})

Response structure


resp.scaling_group_name #=> String
resp.scaling_group_arn #=> String
resp.host_type #=> String
resp.clusters #=> Array
resp.clusters[0] #=> String
resp.availability_zone_id #=> String
resp.status #=> String, one of "CREATING", "CREATE_FAILED", "ACTIVE", "DELETING", "DELETED", "DELETE_FAILED"
resp.status_reason #=> String
resp.last_modified_timestamp #=> Time
resp.created_timestamp #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :scaling_group_name (required, String) —

    A unique identifier for the kdb scaling group.

Returns:

See Also:



2300
2301
2302
2303
 
# File 'lib/aws-sdk-finspace/client.rb', line 2300

def get_kx_scaling_group(params = {}, options = {})
  req = build_request(:get_kx_scaling_group, params)
  req.send_request(options)
end

#get_kx_user(params = {}) ⇒ Types::GetKxUserResponse

Retrieves information about the specified kdb user.

Examples:

Request syntax with placeholder values


resp = client.get_kx_user({
  user_name: "KxUserNameString", # required
  environment_id: "IdType", # required
})

Response structure


resp.user_name #=> String
resp.user_arn #=> String
resp.environment_id #=> String
resp.iam_role #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    A unique identifier for the user.

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

Returns:

See Also:



2338
2339
2340
2341
 
# File 'lib/aws-sdk-finspace/client.rb', line 2338

def get_kx_user(params = {}, options = {})
  req = build_request(:get_kx_user, params)
  req.send_request(options)
end

#get_kx_volume(params = {}) ⇒ Types::GetKxVolumeResponse

Retrieves the information about the volume.

Examples:

Request syntax with placeholder values


resp = client.get_kx_volume({
  environment_id: "KxEnvironmentId", # required
  volume_name: "KxVolumeName", # required
})

Response structure


resp.environment_id #=> String
resp.volume_name #=> String
resp.volume_type #=> String, one of "NAS_1"
resp.volume_arn #=> String
resp.nas1_configuration.type #=> String, one of "SSD_1000", "SSD_250", "HDD_12"
resp.nas1_configuration.size #=> Integer
resp.status #=> String, one of "CREATING", "CREATE_FAILED", "ACTIVE", "UPDATING", "UPDATED", "UPDATE_FAILED", "DELETING", "DELETED", "DELETE_FAILED"
resp.status_reason #=> String
resp.created_timestamp #=> Time
resp.description #=> String
resp.az_mode #=> String, one of "SINGLE", "MULTI"
resp.availability_zone_ids #=> Array
resp.availability_zone_ids[0] #=> String
resp.last_modified_timestamp #=> Time
resp.attached_clusters #=> Array
resp.attached_clusters[0].cluster_name #=> String
resp.attached_clusters[0].cluster_type #=> String, one of "HDB", "RDB", "GATEWAY", "GP", "TICKERPLANT"
resp.attached_clusters[0].cluster_status #=> String, one of "PENDING", "CREATING", "CREATE_FAILED", "RUNNING", "UPDATING", "DELETING", "DELETED", "DELETE_FAILED"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment, whose clusters can attach to the volume.

  • :volume_name (required, String) —

    A unique identifier for the volume.

Returns:

See Also:



2400
2401
2402
2403
 
# File 'lib/aws-sdk-finspace/client.rb', line 2400

def get_kx_volume(params = {}, options = {})
  req = build_request(:get_kx_volume, params)
  req.send_request(options)
end

#list_environments(params = {}) ⇒ Types::ListEnvironmentsResponse

A list of all of your FinSpace environments.

Examples:

Request syntax with placeholder values


resp = client.list_environments({
  next_token: "PaginationToken",
  max_results: 1,
})

Response structure


resp.environments #=> Array
resp.environments[0].name #=> String
resp.environments[0].environment_id #=> String
resp.environments[0]. #=> String
resp.environments[0].status #=> String, one of "CREATE_REQUESTED", "CREATING", "CREATED", "DELETE_REQUESTED", "DELETING", "DELETED", "FAILED_CREATION", "RETRY_DELETION", "FAILED_DELETION", "UPDATE_NETWORK_REQUESTED", "UPDATING_NETWORK", "FAILED_UPDATING_NETWORK", "SUSPENDED"
resp.environments[0].environment_url #=> String
resp.environments[0].description #=> String
resp.environments[0].environment_arn #=> String
resp.environments[0].sage_maker_studio_domain_url #=> String
resp.environments[0].kms_key_id #=> String
resp.environments[0]. #=> String
resp.environments[0].federation_mode #=> String, one of "FEDERATED", "LOCAL"
resp.environments[0].federation_parameters.saml_metadata_document #=> String
resp.environments[0].federation_parameters.saml_metadata_url #=> String
resp.environments[0].federation_parameters.application_call_back_url #=> String
resp.environments[0].federation_parameters.federation_urn #=> String
resp.environments[0].federation_parameters.federation_provider_name #=> String
resp.environments[0].federation_parameters.attribute_map #=> Hash
resp.environments[0].federation_parameters.attribute_map["FederationAttributeKey"] #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :next_token (String) —

    A token generated by FinSpace that specifies where to continue pagination if a previous request was truncated. To get the next set of pages, pass in the ‘nextToken`nextToken value from the response object of the previous page call.

  • :max_results (Integer) —

    The maximum number of results to return in this request.

Returns:

See Also:



2455
2456
2457
2458
 
# File 'lib/aws-sdk-finspace/client.rb', line 2455

def list_environments(params = {}, options = {})
  req = build_request(:list_environments, params)
  req.send_request(options)
end

#list_kx_changesets(params = {}) ⇒ Types::ListKxChangesetsResponse

Returns a list of all the changesets for a database.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_kx_changesets({
  environment_id: "EnvironmentId", # required
  database_name: "DatabaseName", # required
  next_token: "PaginationToken",
  max_results: 1,
})

Response structure


resp.kx_changesets #=> Array
resp.kx_changesets[0].changeset_id #=> String
resp.kx_changesets[0].created_timestamp #=> Time
resp.kx_changesets[0].active_from_timestamp #=> Time
resp.kx_changesets[0].last_modified_timestamp #=> Time
resp.kx_changesets[0].status #=> String, one of "PENDING", "PROCESSING", "FAILED", "COMPLETED"
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :database_name (required, String) —

    The name of the kdb database.

  • :next_token (String) —

    A token that indicates where a results page should begin.

  • :max_results (Integer) —

    The maximum number of results to return in this request.

Returns:

See Also:



2504
2505
2506
2507
 
# File 'lib/aws-sdk-finspace/client.rb', line 2504

def list_kx_changesets(params = {}, options = {})
  req = build_request(:list_kx_changesets, params)
  req.send_request(options)
end

#list_kx_cluster_nodes(params = {}) ⇒ Types::ListKxClusterNodesResponse

Lists all the nodes in a kdb cluster.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_kx_cluster_nodes({
  environment_id: "KxEnvironmentId", # required
  cluster_name: "KxClusterName", # required
  next_token: "PaginationToken",
  max_results: 1,
})

Response structure


resp.nodes #=> Array
resp.nodes[0].node_id #=> String
resp.nodes[0].availability_zone_id #=> String
resp.nodes[0].launch_time #=> Time
resp.nodes[0].status #=> String, one of "RUNNING", "PROVISIONING"
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :cluster_name (required, String) —

    A unique name for the cluster.

  • :next_token (String) —

    A token that indicates where a results page should begin.

  • :max_results (Integer) —

    The maximum number of results to return in this request.

Returns:

See Also:



2552
2553
2554
2555
 
# File 'lib/aws-sdk-finspace/client.rb', line 2552

def list_kx_cluster_nodes(params = {}, options = {})
  req = build_request(:list_kx_cluster_nodes, params)
  req.send_request(options)
end

#list_kx_clusters(params = {}) ⇒ Types::ListKxClustersResponse

Returns a list of clusters.

Examples:

Request syntax with placeholder values


resp = client.list_kx_clusters({
  environment_id: "KxEnvironmentId", # required
  cluster_type: "HDB", # accepts HDB, RDB, GATEWAY, GP, TICKERPLANT
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.kx_cluster_summaries #=> Array
resp.kx_cluster_summaries[0].status #=> String, one of "PENDING", "CREATING", "CREATE_FAILED", "RUNNING", "UPDATING", "DELETING", "DELETED", "DELETE_FAILED"
resp.kx_cluster_summaries[0].status_reason #=> String
resp.kx_cluster_summaries[0].cluster_name #=> String
resp.kx_cluster_summaries[0].cluster_type #=> String, one of "HDB", "RDB", "GATEWAY", "GP", "TICKERPLANT"
resp.kx_cluster_summaries[0].cluster_description #=> String
resp.kx_cluster_summaries[0].release_label #=> String
resp.kx_cluster_summaries[0].volumes #=> Array
resp.kx_cluster_summaries[0].volumes[0].volume_name #=> String
resp.kx_cluster_summaries[0].volumes[0].volume_type #=> String, one of "NAS_1"
resp.kx_cluster_summaries[0].initialization_script #=> String
resp.kx_cluster_summaries[0].execution_role #=> String
resp.kx_cluster_summaries[0].az_mode #=> String, one of "SINGLE", "MULTI"
resp.kx_cluster_summaries[0].availability_zone_id #=> String
resp.kx_cluster_summaries[0].last_modified_timestamp #=> Time
resp.kx_cluster_summaries[0].created_timestamp #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :cluster_type (String) —

    Specifies the type of KDB database that is being created. The following types are available:

    • HDB – A Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed kdb databases mounted to the cluster.

    • RDB – A Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the ‘savedownStorageConfiguration` parameter.

    • GATEWAY – A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.

    • GP – A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only ‘SINGLE` AZ mode.

    • Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.

  • :max_results (Integer) —

    The maximum number of results to return in this request.

  • :next_token (String) —

    A token that indicates where a results page should begin.

Returns:

See Also:



2640
2641
2642
2643
 
# File 'lib/aws-sdk-finspace/client.rb', line 2640

def list_kx_clusters(params = {}, options = {})
  req = build_request(:list_kx_clusters, params)
  req.send_request(options)
end

#list_kx_databases(params = {}) ⇒ Types::ListKxDatabasesResponse

Returns a list of all the databases in the kdb environment.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_kx_databases({
  environment_id: "EnvironmentId", # required
  next_token: "PaginationToken",
  max_results: 1,
})

Response structure


resp.kx_databases #=> Array
resp.kx_databases[0].database_name #=> String
resp.kx_databases[0].created_timestamp #=> Time
resp.kx_databases[0].last_modified_timestamp #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :next_token (String) —

    A token that indicates where a results page should begin.

  • :max_results (Integer) —

    The maximum number of results to return in this request.

Returns:

See Also:



2683
2684
2685
2686
 
# File 'lib/aws-sdk-finspace/client.rb', line 2683

def list_kx_databases(params = {}, options = {})
  req = build_request(:list_kx_databases, params)
  req.send_request(options)
end

#list_kx_dataviews(params = {}) ⇒ Types::ListKxDataviewsResponse

Returns a list of all the dataviews in the database.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_kx_dataviews({
  environment_id: "EnvironmentId", # required
  database_name: "DatabaseName", # required
  next_token: "PaginationToken",
  max_results: 1,
})

Response structure


resp.kx_dataviews #=> Array
resp.kx_dataviews[0].environment_id #=> String
resp.kx_dataviews[0].database_name #=> String
resp.kx_dataviews[0].dataview_name #=> String
resp.kx_dataviews[0].az_mode #=> String, one of "SINGLE", "MULTI"
resp.kx_dataviews[0].availability_zone_id #=> String
resp.kx_dataviews[0].changeset_id #=> String
resp.kx_dataviews[0].segment_configurations #=> Array
resp.kx_dataviews[0].segment_configurations[0].db_paths #=> Array
resp.kx_dataviews[0].segment_configurations[0].db_paths[0] #=> String
resp.kx_dataviews[0].segment_configurations[0].volume_name #=> String
resp.kx_dataviews[0].segment_configurations[0].on_demand #=> Boolean
resp.kx_dataviews[0].active_versions #=> Array
resp.kx_dataviews[0].active_versions[0].changeset_id #=> String
resp.kx_dataviews[0].active_versions[0].segment_configurations #=> Array
resp.kx_dataviews[0].active_versions[0].segment_configurations[0].db_paths #=> Array
resp.kx_dataviews[0].active_versions[0].segment_configurations[0].db_paths[0] #=> String
resp.kx_dataviews[0].active_versions[0].segment_configurations[0].volume_name #=> String
resp.kx_dataviews[0].active_versions[0].segment_configurations[0].on_demand #=> Boolean
resp.kx_dataviews[0].active_versions[0].attached_clusters #=> Array
resp.kx_dataviews[0].active_versions[0].attached_clusters[0] #=> String
resp.kx_dataviews[0].active_versions[0].created_timestamp #=> Time
resp.kx_dataviews[0].active_versions[0].version_id #=> String
resp.kx_dataviews[0].status #=> String, one of "CREATING", "ACTIVE", "UPDATING", "FAILED", "DELETING"
resp.kx_dataviews[0].description #=> String
resp.kx_dataviews[0].auto_update #=> Boolean
resp.kx_dataviews[0].read_write #=> Boolean
resp.kx_dataviews[0].created_timestamp #=> Time
resp.kx_dataviews[0].last_modified_timestamp #=> Time
resp.kx_dataviews[0].status_reason #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment, for which you want to retrieve a list of dataviews.

  • :database_name (required, String) —

    The name of the database where the dataviews were created.

  • :next_token (String) —

    A token that indicates where a results page should begin.

  • :max_results (Integer) —

    The maximum number of results to return in this request.

Returns:

See Also:



2757
2758
2759
2760
 
# File 'lib/aws-sdk-finspace/client.rb', line 2757

def list_kx_dataviews(params = {}, options = {})
  req = build_request(:list_kx_dataviews, params)
  req.send_request(options)
end

#list_kx_environments(params = {}) ⇒ Types::ListKxEnvironmentsResponse

Returns a list of kdb environments created in an account.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_kx_environments({
  next_token: "PaginationToken",
  max_results: 1,
})

Response structure


resp.environments #=> Array
resp.environments[0].name #=> String
resp.environments[0].environment_id #=> String
resp.environments[0]. #=> String
resp.environments[0].status #=> String, one of "CREATE_REQUESTED", "CREATING", "CREATED", "DELETE_REQUESTED", "DELETING", "DELETED", "FAILED_CREATION", "RETRY_DELETION", "FAILED_DELETION", "UPDATE_NETWORK_REQUESTED", "UPDATING_NETWORK", "FAILED_UPDATING_NETWORK", "SUSPENDED"
resp.environments[0].tgw_status #=> String, one of "NONE", "UPDATE_REQUESTED", "UPDATING", "FAILED_UPDATE", "SUCCESSFULLY_UPDATED"
resp.environments[0].dns_status #=> String, one of "NONE", "UPDATE_REQUESTED", "UPDATING", "FAILED_UPDATE", "SUCCESSFULLY_UPDATED"
resp.environments[0].error_message #=> String
resp.environments[0].description #=> String
resp.environments[0].environment_arn #=> String
resp.environments[0].kms_key_id #=> String
resp.environments[0]. #=> String
resp.environments[0].transit_gateway_configuration.transit_gateway_id #=> String
resp.environments[0].transit_gateway_configuration.routable_cidr_space #=> String
resp.environments[0].transit_gateway_configuration.attachment_network_acl_configuration #=> Array
resp.environments[0].transit_gateway_configuration.attachment_network_acl_configuration[0].rule_number #=> Integer
resp.environments[0].transit_gateway_configuration.attachment_network_acl_configuration[0].protocol #=> String
resp.environments[0].transit_gateway_configuration.attachment_network_acl_configuration[0].rule_action #=> String, one of "allow", "deny"
resp.environments[0].transit_gateway_configuration.attachment_network_acl_configuration[0].port_range.from #=> Integer
resp.environments[0].transit_gateway_configuration.attachment_network_acl_configuration[0].port_range.to #=> Integer
resp.environments[0].transit_gateway_configuration.attachment_network_acl_configuration[0].icmp_type_code.type #=> Integer
resp.environments[0].transit_gateway_configuration.attachment_network_acl_configuration[0].icmp_type_code.code #=> Integer
resp.environments[0].transit_gateway_configuration.attachment_network_acl_configuration[0].cidr_block #=> String
resp.environments[0].custom_dns_configuration #=> Array
resp.environments[0].custom_dns_configuration[0].custom_dns_server_name #=> String
resp.environments[0].custom_dns_configuration[0].custom_dns_server_ip #=> String
resp.environments[0].creation_timestamp #=> Time
resp.environments[0].update_timestamp #=> Time
resp.environments[0].availability_zone_ids #=> Array
resp.environments[0].availability_zone_ids[0] #=> String
resp.environments[0].certificate_authority_arn #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :next_token (String) —

    A token that indicates where a results page should begin.

  • :max_results (Integer) —

    The maximum number of results to return in this request.

Returns:

See Also:



2823
2824
2825
2826
 
# File 'lib/aws-sdk-finspace/client.rb', line 2823

def list_kx_environments(params = {}, options = {})
  req = build_request(:list_kx_environments, params)
  req.send_request(options)
end

#list_kx_scaling_groups(params = {}) ⇒ Types::ListKxScalingGroupsResponse

Returns a list of scaling groups in a kdb environment.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_kx_scaling_groups({
  environment_id: "KxEnvironmentId", # required
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.scaling_groups #=> Array
resp.scaling_groups[0].scaling_group_name #=> String
resp.scaling_groups[0].host_type #=> String
resp.scaling_groups[0].clusters #=> Array
resp.scaling_groups[0].clusters[0] #=> String
resp.scaling_groups[0].availability_zone_id #=> String
resp.scaling_groups[0].status #=> String, one of "CREATING", "CREATE_FAILED", "ACTIVE", "DELETING", "DELETED", "DELETE_FAILED"
resp.scaling_groups[0].status_reason #=> String
resp.scaling_groups[0].last_modified_timestamp #=> Time
resp.scaling_groups[0].created_timestamp #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment, for which you want to retrieve a list of scaling groups.

  • :max_results (Integer) —

    The maximum number of results to return in this request.

  • :next_token (String) —

    A token that indicates where a results page should begin.

Returns:

See Also:



2873
2874
2875
2876
 
# File 'lib/aws-sdk-finspace/client.rb', line 2873

def list_kx_scaling_groups(params = {}, options = {})
  req = build_request(:list_kx_scaling_groups, params)
  req.send_request(options)
end

#list_kx_users(params = {}) ⇒ Types::ListKxUsersResponse

Lists all the users in a kdb environment.

Examples:

Request syntax with placeholder values


resp = client.list_kx_users({
  environment_id: "IdType", # required
  next_token: "PaginationToken",
  max_results: 1,
})

Response structure


resp.users #=> Array
resp.users[0].user_arn #=> String
resp.users[0].user_name #=> String
resp.users[0].iam_role #=> String
resp.users[0].create_timestamp #=> Time
resp.users[0].update_timestamp #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :next_token (String) —

    A token that indicates where a results page should begin.

  • :max_results (Integer) —

    The maximum number of results to return in this request.

Returns:

See Also:



2916
2917
2918
2919
 
# File 'lib/aws-sdk-finspace/client.rb', line 2916

def list_kx_users(params = {}, options = {})
  req = build_request(:list_kx_users, params)
  req.send_request(options)
end

#list_kx_volumes(params = {}) ⇒ Types::ListKxVolumesResponse

Lists all the volumes in a kdb environment.

Examples:

Request syntax with placeholder values


resp = client.list_kx_volumes({
  environment_id: "KxEnvironmentId", # required
  max_results: 1,
  next_token: "PaginationToken",
  volume_type: "NAS_1", # accepts NAS_1
})

Response structure


resp.kx_volume_summaries #=> Array
resp.kx_volume_summaries[0].volume_name #=> String
resp.kx_volume_summaries[0].volume_type #=> String, one of "NAS_1"
resp.kx_volume_summaries[0].status #=> String, one of "CREATING", "CREATE_FAILED", "ACTIVE", "UPDATING", "UPDATED", "UPDATE_FAILED", "DELETING", "DELETED", "DELETE_FAILED"
resp.kx_volume_summaries[0].description #=> String
resp.kx_volume_summaries[0].status_reason #=> String
resp.kx_volume_summaries[0].az_mode #=> String, one of "SINGLE", "MULTI"
resp.kx_volume_summaries[0].availability_zone_ids #=> Array
resp.kx_volume_summaries[0].availability_zone_ids[0] #=> String
resp.kx_volume_summaries[0].created_timestamp #=> Time
resp.kx_volume_summaries[0].last_modified_timestamp #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment, whose clusters can attach to the volume.

  • :max_results (Integer) —

    The maximum number of results to return in this request.

  • :next_token (String) —

    A token that indicates where a results page should begin.

  • :volume_type (String) —

    The type of file system volume. Currently, FinSpace only supports ‘NAS_1` volume type.

Returns:

See Also:



2970
2971
2972
2973
 
# File 'lib/aws-sdk-finspace/client.rb', line 2970

def list_kx_volumes(params = {}, options = {})
  req = build_request(:list_kx_volumes, params)
  req.send_request(options)
end

#list_tags_for_resource(params = {}) ⇒ Types::ListTagsForResourceResponse

A list of all tags for a resource.

Examples:

Request syntax with placeholder values


resp = client.list_tags_for_resource({
  resource_arn: "FinSpaceTaggableArn", # required
})

Response structure


resp.tags #=> Hash
resp.tags["TagKey"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The Amazon Resource Name of the resource.

Returns:

See Also:



2999
3000
3001
3002
 
# File 'lib/aws-sdk-finspace/client.rb', line 2999

def list_tags_for_resource(params = {}, options = {})
  req = build_request(:list_tags_for_resource, params)
  req.send_request(options)
end

#tag_resource(params = {}) ⇒ Struct

Adds metadata tags to a FinSpace resource.

Examples:

Request syntax with placeholder values


resp = client.tag_resource({
  resource_arn: "FinSpaceTaggableArn", # required
  tags: { # required
    "TagKey" => "TagValue",
  },
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The Amazon Resource Name (ARN) for the resource.

  • :tags (required, Hash<String,String>) —

    One or more tags to be assigned to the resource.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3027
3028
3029
3030
 
# File 'lib/aws-sdk-finspace/client.rb', line 3027

def tag_resource(params = {}, options = {})
  req = build_request(:tag_resource, params)
  req.send_request(options)
end

#untag_resource(params = {}) ⇒ Struct

Removes metadata tags from a FinSpace resource.

Examples:

Request syntax with placeholder values


resp = client.untag_resource({
  resource_arn: "FinSpaceTaggableArn", # required
  tag_keys: ["TagKey"], # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    A FinSpace resource from which you want to remove a tag or tags. The value for this parameter is an Amazon Resource Name (ARN).

  • :tag_keys (required, Array<String>) —

    The tag keys (names) of one or more tags to be removed.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3054
3055
3056
3057
 
# File 'lib/aws-sdk-finspace/client.rb', line 3054

def untag_resource(params = {}, options = {})
  req = build_request(:untag_resource, params)
  req.send_request(options)
end

#update_environment(params = {}) ⇒ Types::UpdateEnvironmentResponse

Update your FinSpace environment.

Examples:

Request syntax with placeholder values


resp = client.update_environment({
  environment_id: "IdType", # required
  name: "EnvironmentName",
  description: "Description",
  federation_mode: "FEDERATED", # accepts FEDERATED, LOCAL
  federation_parameters: {
    saml_metadata_document: "SamlMetadataDocument",
    saml_metadata_url: "url",
    application_call_back_url: "url",
    federation_urn: "urn",
    federation_provider_name: "FederationProviderName",
    attribute_map: {
      "FederationAttributeKey" => "FederationAttributeValue",
    },
  },
})

Response structure


resp.environment.name #=> String
resp.environment.environment_id #=> String
resp.environment. #=> String
resp.environment.status #=> String, one of "CREATE_REQUESTED", "CREATING", "CREATED", "DELETE_REQUESTED", "DELETING", "DELETED", "FAILED_CREATION", "RETRY_DELETION", "FAILED_DELETION", "UPDATE_NETWORK_REQUESTED", "UPDATING_NETWORK", "FAILED_UPDATING_NETWORK", "SUSPENDED"
resp.environment.environment_url #=> String
resp.environment.description #=> String
resp.environment.environment_arn #=> String
resp.environment.sage_maker_studio_domain_url #=> String
resp.environment.kms_key_id #=> String
resp.environment. #=> String
resp.environment.federation_mode #=> String, one of "FEDERATED", "LOCAL"
resp.environment.federation_parameters.saml_metadata_document #=> String
resp.environment.federation_parameters.saml_metadata_url #=> String
resp.environment.federation_parameters.application_call_back_url #=> String
resp.environment.federation_parameters.federation_urn #=> String
resp.environment.federation_parameters.federation_provider_name #=> String
resp.environment.federation_parameters.attribute_map #=> Hash
resp.environment.federation_parameters.attribute_map["FederationAttributeKey"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    The identifier of the FinSpace environment.

  • :name (String) —

    The name of the environment.

  • :description (String) —

    The description of the environment.

  • :federation_mode (String) —

    Authentication mode for the environment.

    • ‘FEDERATED` - Users access FinSpace through Single Sign On (SSO) via your Identity provider.

    • ‘LOCAL` - Users access FinSpace via email and password managed within the FinSpace environment.

  • :federation_parameters (Types::FederationParameters) —

    Configuration information when authentication mode is FEDERATED.

Returns:

See Also:



3130
3131
3132
3133
 
# File 'lib/aws-sdk-finspace/client.rb', line 3130

def update_environment(params = {}, options = {})
  req = build_request(:update_environment, params)
  req.send_request(options)
end

#update_kx_cluster_code_configuration(params = {}) ⇒ Struct

Allows you to update code configuration on a running cluster. By using this API you can update the code, the initialization script path, and the command line arguments for a specific cluster. The configuration that you want to update will override any existing configurations on the cluster.

Examples:

Request syntax with placeholder values


resp = client.update_kx_cluster_code_configuration({
  environment_id: "KxEnvironmentId", # required
  cluster_name: "KxClusterName", # required
  client_token: "ClientTokenString",
  code: { # required
    s3_bucket: "S3Bucket",
    s3_key: "S3Key",
    s3_object_version: "S3ObjectVersion",
  },
  initialization_script: "InitializationScriptFilePath",
  command_line_arguments: [
    {
      key: "KxCommandLineArgumentKey",
      value: "KxCommandLineArgumentValue",
    },
  ],
  deployment_configuration: {
    deployment_strategy: "NO_RESTART", # required, accepts NO_RESTART, ROLLING, FORCE
  },
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier of the kdb environment.

  • :cluster_name (required, String) —

    The name of the cluster.

  • :client_token (String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :code (required, Types::CodeConfiguration) —

    The structure of the customer code available within the running cluster.

  • :initialization_script (String) —

    Specifies a Q program that will be run at launch of a cluster. It is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, ‘somedir/init.q`.

    You cannot update this parameter for a ‘NO_RESTART` deployment.

  • :command_line_arguments (Array<Types::KxCommandLineArgument>) —

    Specifies the key-value pairs to make them available inside the cluster.

    You cannot update this parameter for a ‘NO_RESTART` deployment.

  • :deployment_configuration (Types::KxClusterCodeDeploymentConfiguration) —

    The configuration that allows you to choose how you want to update the code on a cluster.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3204
3205
3206
3207
 
# File 'lib/aws-sdk-finspace/client.rb', line 3204

def update_kx_cluster_code_configuration(params = {}, options = {})
  req = build_request(:update_kx_cluster_code_configuration, params)
  req.send_request(options)
end

#update_kx_cluster_databases(params = {}) ⇒ Struct

Updates the databases mounted on a kdb cluster, which includes the ‘changesetId` and all the dbPaths to be cached. This API does not allow you to change a database name or add a database if you created a cluster without one.

Using this API you can point a cluster to a different changeset and modify a list of partitions being cached.

Examples:

Request syntax with placeholder values


resp = client.update_kx_cluster_databases({
  environment_id: "KxEnvironmentId", # required
  cluster_name: "KxClusterName", # required
  client_token: "ClientTokenString",
  databases: [ # required
    {
      database_name: "DatabaseName", # required
      cache_configurations: [
        {
          cache_type: "KxCacheStorageType", # required
          db_paths: ["DbPath"], # required
          dataview_name: "KxDataviewName",
        },
      ],
      changeset_id: "ChangesetId",
      dataview_name: "KxDataviewName",
      dataview_configuration: {
        dataview_name: "KxDataviewName",
        dataview_version_id: "VersionId",
        changeset_id: "ChangesetId",
        segment_configurations: [
          {
            db_paths: ["DbPath"], # required
            volume_name: "KxVolumeName", # required
            on_demand: false,
          },
        ],
      },
    },
  ],
  deployment_configuration: {
    deployment_strategy: "NO_RESTART", # required, accepts NO_RESTART, ROLLING
  },
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    The unique identifier of a kdb environment.

  • :cluster_name (required, String) —

    A unique name for the cluster that you want to modify.

  • :client_token (String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :databases (required, Array<Types::KxDatabaseConfiguration>) —

    The structure of databases mounted on the cluster.

  • :deployment_configuration (Types::KxDeploymentConfiguration) —

    The configuration that allows you to choose how you want to update the databases on a cluster.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3279
3280
3281
3282
 
# File 'lib/aws-sdk-finspace/client.rb', line 3279

def update_kx_cluster_databases(params = {}, options = {})
  req = build_request(:update_kx_cluster_databases, params)
  req.send_request(options)
end

#update_kx_database(params = {}) ⇒ Types::UpdateKxDatabaseResponse

Updates information for the given kdb database.

Examples:

Request syntax with placeholder values


resp = client.update_kx_database({
  environment_id: "EnvironmentId", # required
  database_name: "DatabaseName", # required
  description: "Description",
  client_token: "ClientTokenString", # required
})

Response structure


resp.database_name #=> String
resp.environment_id #=> String
resp.description #=> String
resp.last_modified_timestamp #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :database_name (required, String) —

    The name of the kdb database.

  • :description (String) —

    A description of the database.

  • :client_token (required, String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

See Also:



3328
3329
3330
3331
 
# File 'lib/aws-sdk-finspace/client.rb', line 3328

def update_kx_database(params = {}, options = {})
  req = build_request(:update_kx_database, params)
  req.send_request(options)
end

#update_kx_dataview(params = {}) ⇒ Types::UpdateKxDataviewResponse

Updates the specified dataview. The dataviews get automatically updated when any new changesets are ingested. Each update of the dataview creates a new version, including changeset details and cache configurations

Examples:

Request syntax with placeholder values


resp = client.update_kx_dataview({
  environment_id: "EnvironmentId", # required
  database_name: "DatabaseName", # required
  dataview_name: "KxDataviewName", # required
  description: "Description",
  changeset_id: "ChangesetId",
  segment_configurations: [
    {
      db_paths: ["DbPath"], # required
      volume_name: "KxVolumeName", # required
      on_demand: false,
    },
  ],
  client_token: "ClientTokenString", # required
})

Response structure


resp.environment_id #=> String
resp.database_name #=> String
resp.dataview_name #=> String
resp.az_mode #=> String, one of "SINGLE", "MULTI"
resp.availability_zone_id #=> String
resp.changeset_id #=> String
resp.segment_configurations #=> Array
resp.segment_configurations[0].db_paths #=> Array
resp.segment_configurations[0].db_paths[0] #=> String
resp.segment_configurations[0].volume_name #=> String
resp.segment_configurations[0].on_demand #=> Boolean
resp.active_versions #=> Array
resp.active_versions[0].changeset_id #=> String
resp.active_versions[0].segment_configurations #=> Array
resp.active_versions[0].segment_configurations[0].db_paths #=> Array
resp.active_versions[0].segment_configurations[0].db_paths[0] #=> String
resp.active_versions[0].segment_configurations[0].volume_name #=> String
resp.active_versions[0].segment_configurations[0].on_demand #=> Boolean
resp.active_versions[0].attached_clusters #=> Array
resp.active_versions[0].attached_clusters[0] #=> String
resp.active_versions[0].created_timestamp #=> Time
resp.active_versions[0].version_id #=> String
resp.status #=> String, one of "CREATING", "ACTIVE", "UPDATING", "FAILED", "DELETING"
resp.auto_update #=> Boolean
resp.read_write #=> Boolean
resp.description #=> String
resp.created_timestamp #=> Time
resp.last_modified_timestamp #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment, where you want to update the dataview.

  • :database_name (required, String) —

    The name of the database.

  • :dataview_name (required, String) —

    The name of the dataview that you want to update.

  • :description (String) —

    The description for a dataview.

  • :changeset_id (String) —

    A unique identifier for the changeset.

  • :segment_configurations (Array<Types::KxDataviewSegmentConfiguration>) —

    The configuration that contains the database path of the data that you want to place on each selected volume. Each segment must have a unique database path for each volume. If you do not explicitly specify any database path for a volume, they are accessible from the cluster through the default S3/object store segment.

  • :client_token (required, String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

See Also:



3437
3438
3439
3440
 
# File 'lib/aws-sdk-finspace/client.rb', line 3437

def update_kx_dataview(params = {}, options = {})
  req = build_request(:update_kx_dataview, params)
  req.send_request(options)
end

#update_kx_environment(params = {}) ⇒ Types::UpdateKxEnvironmentResponse

Updates information for the given kdb environment.

Examples:

Request syntax with placeholder values


resp = client.update_kx_environment({
  environment_id: "IdType", # required
  name: "KxEnvironmentName",
  description: "Description",
  client_token: "ClientToken",
})

Response structure


resp.name #=> String
resp.environment_id #=> String
resp. #=> String
resp.status #=> String, one of "CREATE_REQUESTED", "CREATING", "CREATED", "DELETE_REQUESTED", "DELETING", "DELETED", "FAILED_CREATION", "RETRY_DELETION", "FAILED_DELETION", "UPDATE_NETWORK_REQUESTED", "UPDATING_NETWORK", "FAILED_UPDATING_NETWORK", "SUSPENDED"
resp.tgw_status #=> String, one of "NONE", "UPDATE_REQUESTED", "UPDATING", "FAILED_UPDATE", "SUCCESSFULLY_UPDATED"
resp.dns_status #=> String, one of "NONE", "UPDATE_REQUESTED", "UPDATING", "FAILED_UPDATE", "SUCCESSFULLY_UPDATED"
resp.error_message #=> String
resp.description #=> String
resp.environment_arn #=> String
resp.kms_key_id #=> String
resp. #=> String
resp.transit_gateway_configuration.transit_gateway_id #=> String
resp.transit_gateway_configuration.routable_cidr_space #=> String
resp.transit_gateway_configuration.attachment_network_acl_configuration #=> Array
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].rule_number #=> Integer
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].protocol #=> String
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].rule_action #=> String, one of "allow", "deny"
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].port_range.from #=> Integer
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].port_range.to #=> Integer
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].icmp_type_code.type #=> Integer
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].icmp_type_code.code #=> Integer
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].cidr_block #=> String
resp.custom_dns_configuration #=> Array
resp.custom_dns_configuration[0].custom_dns_server_name #=> String
resp.custom_dns_configuration[0].custom_dns_server_ip #=> String
resp.creation_timestamp #=> Time
resp.update_timestamp #=> Time
resp.availability_zone_ids #=> Array
resp.availability_zone_ids[0] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :name (String) —

    The name of the kdb environment.

  • :description (String) —

    A description of the kdb environment.

  • :client_token (String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

See Also:



3523
3524
3525
3526
 
# File 'lib/aws-sdk-finspace/client.rb', line 3523

def update_kx_environment(params = {}, options = {})
  req = build_request(:update_kx_environment, params)
  req.send_request(options)
end

#update_kx_environment_network(params = {}) ⇒ Types::UpdateKxEnvironmentNetworkResponse

Updates environment network to connect to your internal network by using a transit gateway. This API supports request to create a transit gateway attachment from FinSpace VPC to your transit gateway ID and create a custom Route-53 outbound resolvers.

Once you send a request to update a network, you cannot change it again. Network update might require termination of any clusters that are running in the existing network.

Examples:

Request syntax with placeholder values


resp = client.update_kx_environment_network({
  environment_id: "IdType", # required
  transit_gateway_configuration: {
    transit_gateway_id: "TransitGatewayID", # required
    routable_cidr_space: "ValidCIDRSpace", # required
    attachment_network_acl_configuration: [
      {
        rule_number: 1, # required
        protocol: "Protocol", # required
        rule_action: "allow", # required, accepts allow, deny
        port_range: {
          from: 1, # required
          to: 1, # required
        },
        icmp_type_code: {
          type: 1, # required
          code: 1, # required
        },
        cidr_block: "ValidCIDRBlock", # required
      },
    ],
  },
  custom_dns_configuration: [
    {
      custom_dns_server_name: "ValidHostname", # required
      custom_dns_server_ip: "ValidIPAddress", # required
    },
  ],
  client_token: "ClientToken",
})

Response structure


resp.name #=> String
resp.environment_id #=> String
resp. #=> String
resp.status #=> String, one of "CREATE_REQUESTED", "CREATING", "CREATED", "DELETE_REQUESTED", "DELETING", "DELETED", "FAILED_CREATION", "RETRY_DELETION", "FAILED_DELETION", "UPDATE_NETWORK_REQUESTED", "UPDATING_NETWORK", "FAILED_UPDATING_NETWORK", "SUSPENDED"
resp.tgw_status #=> String, one of "NONE", "UPDATE_REQUESTED", "UPDATING", "FAILED_UPDATE", "SUCCESSFULLY_UPDATED"
resp.dns_status #=> String, one of "NONE", "UPDATE_REQUESTED", "UPDATING", "FAILED_UPDATE", "SUCCESSFULLY_UPDATED"
resp.error_message #=> String
resp.description #=> String
resp.environment_arn #=> String
resp.kms_key_id #=> String
resp. #=> String
resp.transit_gateway_configuration.transit_gateway_id #=> String
resp.transit_gateway_configuration.routable_cidr_space #=> String
resp.transit_gateway_configuration.attachment_network_acl_configuration #=> Array
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].rule_number #=> Integer
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].protocol #=> String
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].rule_action #=> String, one of "allow", "deny"
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].port_range.from #=> Integer
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].port_range.to #=> Integer
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].icmp_type_code.type #=> Integer
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].icmp_type_code.code #=> Integer
resp.transit_gateway_configuration.attachment_network_acl_configuration[0].cidr_block #=> String
resp.custom_dns_configuration #=> Array
resp.custom_dns_configuration[0].custom_dns_server_name #=> String
resp.custom_dns_configuration[0].custom_dns_server_ip #=> String
resp.creation_timestamp #=> Time
resp.update_timestamp #=> Time
resp.availability_zone_ids #=> Array
resp.availability_zone_ids[0] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :transit_gateway_configuration (Types::TransitGatewayConfiguration) —

    Specifies the transit gateway and network configuration to connect the kdb environment to an internal network.

  • :custom_dns_configuration (Array<Types::CustomDNSServer>) —

    A list of DNS server name and server IP. This is used to set up Route-53 outbound resolvers.

  • :client_token (String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

See Also:



3642
3643
3644
3645
 
# File 'lib/aws-sdk-finspace/client.rb', line 3642

def update_kx_environment_network(params = {}, options = {})
  req = build_request(:update_kx_environment_network, params)
  req.send_request(options)
end

#update_kx_user(params = {}) ⇒ Types::UpdateKxUserResponse

Updates the user details. You can only update the IAM role associated with a user.

Examples:

Request syntax with placeholder values


resp = client.update_kx_user({
  environment_id: "IdType", # required
  user_name: "KxUserNameString", # required
  iam_role: "RoleArn", # required
  client_token: "ClientToken",
})

Response structure


resp.user_name #=> String
resp.user_arn #=> String
resp.environment_id #=> String
resp.iam_role #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment.

  • :user_name (required, String) —

    A unique identifier for the user.

  • :iam_role (required, String) —

    The IAM role ARN that is associated with the user.

  • :client_token (String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

See Also:



3692
3693
3694
3695
 
# File 'lib/aws-sdk-finspace/client.rb', line 3692

def update_kx_user(params = {}, options = {})
  req = build_request(:update_kx_user, params)
  req.send_request(options)
end

#update_kx_volume(params = {}) ⇒ Types::UpdateKxVolumeResponse

Updates the throughput or capacity of a volume. During the update process, the filesystem might be unavailable for a few minutes. You can retry any operations after the update is complete.

Examples:

Request syntax with placeholder values


resp = client.update_kx_volume({
  environment_id: "KxEnvironmentId", # required
  volume_name: "KxVolumeName", # required
  description: "Description",
  client_token: "ClientTokenString",
  nas1_configuration: {
    type: "SSD_1000", # accepts SSD_1000, SSD_250, HDD_12
    size: 1,
  },
})

Response structure


resp.environment_id #=> String
resp.volume_name #=> String
resp.volume_type #=> String, one of "NAS_1"
resp.volume_arn #=> String
resp.nas1_configuration.type #=> String, one of "SSD_1000", "SSD_250", "HDD_12"
resp.nas1_configuration.size #=> Integer
resp.status #=> String, one of "CREATING", "CREATE_FAILED", "ACTIVE", "UPDATING", "UPDATED", "UPDATE_FAILED", "DELETING", "DELETED", "DELETE_FAILED"
resp.description #=> String
resp.status_reason #=> String
resp.created_timestamp #=> Time
resp.az_mode #=> String, one of "SINGLE", "MULTI"
resp.availability_zone_ids #=> Array
resp.availability_zone_ids[0] #=> String
resp.last_modified_timestamp #=> Time
resp.attached_clusters #=> Array
resp.attached_clusters[0].cluster_name #=> String
resp.attached_clusters[0].cluster_type #=> String, one of "HDB", "RDB", "GATEWAY", "GP", "TICKERPLANT"
resp.attached_clusters[0].cluster_status #=> String, one of "PENDING", "CREATING", "CREATE_FAILED", "RUNNING", "UPDATING", "DELETING", "DELETED", "DELETE_FAILED"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :environment_id (required, String) —

    A unique identifier for the kdb environment where you created the storage volume.

  • :volume_name (required, String) —

    A unique identifier for the volume.

  • :description (String) —

    A description of the volume.

  • :client_token (String) —

    A token that ensures idempotency. This token expires in 10 minutes.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :nas1_configuration (Types::KxNAS1Configuration) —

    Specifies the configuration for the Network attached storage (NAS_1) file system volume.

Returns:

See Also:



3775
3776
3777
3778
 
# File 'lib/aws-sdk-finspace/client.rb', line 3775

def update_kx_volume(params = {}, options = {})
  req = build_request(:update_kx_volume, params)
  req.send_request(options)
end

#waiter_names ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Deprecated. 


3804
3805
3806
 
# File 'lib/aws-sdk-finspace/client.rb', line 3804

def waiter_names
  []
end