Class: Aws::Greengrass::Client

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

Overview

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

client = Aws::Greengrass::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::Greengrass::EndpointProvider) —

    The endpoint provider used to resolve endpoints. Any object that responds to ‘#resolve_endpoint(parameters)` where `parameters` is a Struct similar to `Aws::Greengrass::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.



444
445
446
 
# File 'lib/aws-sdk-greengrass/client.rb', line 444

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. 



4238
4239
4240
 
# File 'lib/aws-sdk-greengrass/client.rb', line 4238

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. 



4241
4242
4243
 
# File 'lib/aws-sdk-greengrass/client.rb', line 4241

def errors_module
  Errors
end

Instance Method Details

#associate_role_to_group(params = {}) ⇒ Types::AssociateRoleToGroupResponse

Associates a role with a group. Your Greengrass core will use the role to access AWS cloud services. The role’s permissions should allow Greengrass core Lambda functions to perform actions against the cloud.

Examples:

Request syntax with placeholder values


resp = client.associate_role_to_group({
  group_id: "__string", # required
  role_arn: "__string", # required
})

Response structure


resp.associated_at #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :group_id (required, String)
  • :role_arn (required, String) —

    The ARN of the role you wish to associate with this group. The existence of the role is not validated.

Returns:

See Also:



479
480
481
482
 
# File 'lib/aws-sdk-greengrass/client.rb', line 479

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

#associate_service_role_to_account(params = {}) ⇒ Types::AssociateServiceRoleToAccountResponse

Associates a role with your account. AWS IoT Greengrass will use the role to access your Lambda functions and AWS IoT resources. This is necessary for deployments to succeed. The role must have at least minimum permissions in the policy ”AWSGreengrassResourceAccessRolePolicy”.

Examples:

Request syntax with placeholder values


resp = client.({
  role_arn: "__string", # required
})

Response structure


resp.associated_at #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :role_arn (required, String) —

    The ARN of the service role you wish to associate with your account.

Returns:

See Also:



511
512
513
514
 
# File 'lib/aws-sdk-greengrass/client.rb', line 511

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

#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: {}) 


4211
4212
4213
4214
4215
4216
4217
4218
4219
4220
4221
4222
4223
4224
4225
4226
4227
 
# File 'lib/aws-sdk-greengrass/client.rb', line 4211

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::Greengrass')
  )
  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-greengrass'
  context[:gem_version] = '1.76.0'
  Seahorse::Client::Request.new(handlers, context)
end

#create_connector_definition(params = {}) ⇒ Types::CreateConnectorDefinitionResponse

Creates a connector definition. You may provide the initial version of the connector definition now or use ”CreateConnectorDefinitionVersion” at a later time.

Examples:

Request syntax with placeholder values


resp = client.create_connector_definition({
  amzn_client_token: "__string",
  initial_version: {
    connectors: [
      {
        connector_arn: "__string", # required
        id: "__string", # required
        parameters: {
          "__string" => "__string",
        },
      },
    ],
  },
  name: "__string",
  tags: {
    "__string" => "__string",
  },
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.last_updated_timestamp #=> String
resp.latest_version #=> String
resp.latest_version_arn #=> String
resp.name #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :initial_version (Types::ConnectorDefinitionVersion) —

    Information about the connector definition version, which is a container for connectors.

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

    The key-value pair for the resource tag.

Returns:

See Also:



576
577
578
579
 
# File 'lib/aws-sdk-greengrass/client.rb', line 576

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

#create_connector_definition_version(params = {}) ⇒ Types::CreateConnectorDefinitionVersionResponse

Creates a version of a connector definition which has already been defined.

Examples:

Request syntax with placeholder values


resp = client.create_connector_definition_version({
  amzn_client_token: "__string",
  connector_definition_id: "__string", # required
  connectors: [
    {
      connector_arn: "__string", # required
      id: "__string", # required
      parameters: {
        "__string" => "__string",
      },
    },
  ],
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :connector_definition_id (required, String)
  • :connectors (Array<Types::Connector>)

Returns:

See Also:



624
625
626
627
 
# File 'lib/aws-sdk-greengrass/client.rb', line 624

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

#create_core_definition(params = {}) ⇒ Types::CreateCoreDefinitionResponse

Creates a core definition. You may provide the initial version of the core definition now or use ”CreateCoreDefinitionVersion” at a later time. Greengrass groups must each contain exactly one Greengrass core.

Examples:

Request syntax with placeholder values


resp = client.create_core_definition({
  amzn_client_token: "__string",
  initial_version: {
    cores: [
      {
        certificate_arn: "__string", # required
        id: "__string", # required
        sync_shadow: false,
        thing_arn: "__string", # required
      },
    ],
  },
  name: "__string",
  tags: {
    "__string" => "__string",
  },
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.last_updated_timestamp #=> String
resp.latest_version #=> String
resp.latest_version_arn #=> String
resp.name #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :initial_version (Types::CoreDefinitionVersion) —

    Information about a core definition version.

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

    The key-value pair for the resource tag.

Returns:

See Also:



688
689
690
691
 
# File 'lib/aws-sdk-greengrass/client.rb', line 688

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

#create_core_definition_version(params = {}) ⇒ Types::CreateCoreDefinitionVersionResponse

Creates a version of a core definition that has already been defined. Greengrass groups must each contain exactly one Greengrass core.

Examples:

Request syntax with placeholder values


resp = client.create_core_definition_version({
  amzn_client_token: "__string",
  core_definition_id: "__string", # required
  cores: [
    {
      certificate_arn: "__string", # required
      id: "__string", # required
      sync_shadow: false,
      thing_arn: "__string", # required
    },
  ],
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :core_definition_id (required, String)
  • :cores (Array<Types::Core>)

Returns:

See Also:



735
736
737
738
 
# File 'lib/aws-sdk-greengrass/client.rb', line 735

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

#create_deployment(params = {}) ⇒ Types::CreateDeploymentResponse

Creates a deployment. ”CreateDeployment” requests are idempotent with respect to the ”X-Amzn-Client-Token” token and the request parameters.

Examples:

Request syntax with placeholder values


resp = client.create_deployment({
  amzn_client_token: "__string",
  deployment_id: "__string",
  deployment_type: "NewDeployment", # required, accepts NewDeployment, Redeployment, ResetDeployment, ForceResetDeployment
  group_id: "__string", # required
  group_version_id: "__string",
})

Response structure


resp.deployment_arn #=> String
resp.deployment_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :deployment_id (String) —

    The ID of the deployment if you wish to redeploy a previous deployment.

  • :deployment_type (required, String) —

    The type of deployment. When used for ”CreateDeployment”, only ”NewDeployment” and ”Redeployment” are valid.

  • :group_id (required, String)
  • :group_version_id (String) —

    The ID of the group version to be deployed.

Returns:

See Also:



783
784
785
786
 
# File 'lib/aws-sdk-greengrass/client.rb', line 783

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

#create_device_definition(params = {}) ⇒ Types::CreateDeviceDefinitionResponse

Creates a device definition. You may provide the initial version of the device definition now or use ”CreateDeviceDefinitionVersion” at a later time.

Examples:

Request syntax with placeholder values


resp = client.create_device_definition({
  amzn_client_token: "__string",
  initial_version: {
    devices: [
      {
        certificate_arn: "__string", # required
        id: "__string", # required
        sync_shadow: false,
        thing_arn: "__string", # required
      },
    ],
  },
  name: "__string",
  tags: {
    "__string" => "__string",
  },
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.last_updated_timestamp #=> String
resp.latest_version #=> String
resp.latest_version_arn #=> String
resp.name #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :initial_version (Types::DeviceDefinitionVersion) —

    Information about a device definition version.

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

    The key-value pair for the resource tag.

Returns:

See Also:



846
847
848
849
 
# File 'lib/aws-sdk-greengrass/client.rb', line 846

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

#create_device_definition_version(params = {}) ⇒ Types::CreateDeviceDefinitionVersionResponse

Creates a version of a device definition that has already been defined.

Examples:

Request syntax with placeholder values


resp = client.create_device_definition_version({
  amzn_client_token: "__string",
  device_definition_id: "__string", # required
  devices: [
    {
      certificate_arn: "__string", # required
      id: "__string", # required
      sync_shadow: false,
      thing_arn: "__string", # required
    },
  ],
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :device_definition_id (required, String)
  • :devices (Array<Types::Device>)

Returns:

See Also:



893
894
895
896
 
# File 'lib/aws-sdk-greengrass/client.rb', line 893

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

#create_function_definition(params = {}) ⇒ Types::CreateFunctionDefinitionResponse

Creates a Lambda function definition which contains a list of Lambda functions and their configurations to be used in a group. You can create an initial version of the definition by providing a list of Lambda functions and their configurations now, or use ”CreateFunctionDefinitionVersion” later.

Examples:

Request syntax with placeholder values


resp = client.create_function_definition({
  amzn_client_token: "__string",
  initial_version: {
    default_config: {
      execution: {
        isolation_mode: "GreengrassContainer", # accepts GreengrassContainer, NoContainer
        run_as: {
          gid: 1,
          uid: 1,
        },
      },
    },
    functions: [
      {
        function_arn: "__string",
        function_configuration: {
          encoding_type: "binary", # accepts binary, json
          environment: {
            access_sysfs: false,
            execution: {
              isolation_mode: "GreengrassContainer", # accepts GreengrassContainer, NoContainer
              run_as: {
                gid: 1,
                uid: 1,
              },
            },
            resource_access_policies: [
              {
                permission: "ro", # accepts ro, rw
                resource_id: "__string", # required
              },
            ],
            variables: {
              "__string" => "__string",
            },
          },
          exec_args: "__string",
          executable: "__string",
          memory_size: 1,
          pinned: false,
          timeout: 1,
          function_runtime_override: "__string",
        },
        id: "__string", # required
      },
    ],
  },
  name: "__string",
  tags: {
    "__string" => "__string",
  },
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.last_updated_timestamp #=> String
resp.latest_version #=> String
resp.latest_version_arn #=> String
resp.name #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :initial_version (Types::FunctionDefinitionVersion) —

    Information about a function definition version.

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

    The key-value pair for the resource tag.

Returns:

See Also:



993
994
995
996
 
# File 'lib/aws-sdk-greengrass/client.rb', line 993

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

#create_function_definition_version(params = {}) ⇒ Types::CreateFunctionDefinitionVersionResponse

Creates a version of a Lambda function definition that has already been defined.

Examples:

Request syntax with placeholder values


resp = client.create_function_definition_version({
  amzn_client_token: "__string",
  default_config: {
    execution: {
      isolation_mode: "GreengrassContainer", # accepts GreengrassContainer, NoContainer
      run_as: {
        gid: 1,
        uid: 1,
      },
    },
  },
  function_definition_id: "__string", # required
  functions: [
    {
      function_arn: "__string",
      function_configuration: {
        encoding_type: "binary", # accepts binary, json
        environment: {
          access_sysfs: false,
          execution: {
            isolation_mode: "GreengrassContainer", # accepts GreengrassContainer, NoContainer
            run_as: {
              gid: 1,
              uid: 1,
            },
          },
          resource_access_policies: [
            {
              permission: "ro", # accepts ro, rw
              resource_id: "__string", # required
            },
          ],
          variables: {
            "__string" => "__string",
          },
        },
        exec_args: "__string",
        executable: "__string",
        memory_size: 1,
        pinned: false,
        timeout: 1,
        function_runtime_override: "__string",
      },
      id: "__string", # required
    },
  ],
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :default_config (Types::FunctionDefaultConfig) —

    The default configuration that applies to all Lambda functions in the group. Individual Lambda functions can override these settings.

  • :function_definition_id (required, String)
  • :functions (Array<Types::Function>)

Returns:

See Also:



1079
1080
1081
1082
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1079

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

#create_group(params = {}) ⇒ Types::CreateGroupResponse

Creates a group. You may provide the initial version of the group or use ”CreateGroupVersion” at a later time. Tip: You can use the ”gg_group_setup” package (github.com/awslabs/aws-greengrass-group-setup) as a library or command-line application to create and deploy Greengrass groups.

Examples:

Request syntax with placeholder values


resp = client.create_group({
  amzn_client_token: "__string",
  initial_version: {
    connector_definition_version_arn: "__string",
    core_definition_version_arn: "__string",
    device_definition_version_arn: "__string",
    function_definition_version_arn: "__string",
    logger_definition_version_arn: "__string",
    resource_definition_version_arn: "__string",
    subscription_definition_version_arn: "__string",
  },
  name: "__string", # required
  tags: {
    "__string" => "__string",
  },
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.last_updated_timestamp #=> String
resp.latest_version #=> String
resp.latest_version_arn #=> String
resp.name #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :initial_version (Types::GroupVersion) —

    Information about a group version.

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

    The key-value pair for the resource tag.

Returns:

See Also:



1143
1144
1145
1146
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1143

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

#create_group_certificate_authority(params = {}) ⇒ Types::CreateGroupCertificateAuthorityResponse

Creates a CA for the group. If a CA already exists, it will rotate the existing CA.

Examples:

Request syntax with placeholder values


resp = client.create_group_certificate_authority({
  amzn_client_token: "__string",
  group_id: "__string", # required
})

Response structure


resp.group_certificate_authority_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :group_id (required, String)

Returns:

See Also:



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

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

#create_group_version(params = {}) ⇒ Types::CreateGroupVersionResponse

Creates a version of a group which has already been defined.

Examples:

Request syntax with placeholder values


resp = client.create_group_version({
  amzn_client_token: "__string",
  connector_definition_version_arn: "__string",
  core_definition_version_arn: "__string",
  device_definition_version_arn: "__string",
  function_definition_version_arn: "__string",
  group_id: "__string", # required
  logger_definition_version_arn: "__string",
  resource_definition_version_arn: "__string",
  subscription_definition_version_arn: "__string",
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :connector_definition_version_arn (String)
  • :core_definition_version_arn (String)
  • :device_definition_version_arn (String)
  • :function_definition_version_arn (String)
  • :group_id (required, String)
  • :logger_definition_version_arn (String)
  • :resource_definition_version_arn (String)
  • :subscription_definition_version_arn (String)

Returns:

See Also:



1231
1232
1233
1234
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1231

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

#create_logger_definition(params = {}) ⇒ Types::CreateLoggerDefinitionResponse

Creates a logger definition. You may provide the initial version of the logger definition now or use ”CreateLoggerDefinitionVersion” at a later time.

Examples:

Request syntax with placeholder values


resp = client.create_logger_definition({
  amzn_client_token: "__string",
  initial_version: {
    loggers: [
      {
        component: "GreengrassSystem", # required, accepts GreengrassSystem, Lambda
        id: "__string", # required
        level: "DEBUG", # required, accepts DEBUG, INFO, WARN, ERROR, FATAL
        space: 1,
        type: "FileSystem", # required, accepts FileSystem, AWSCloudWatch
      },
    ],
  },
  name: "__string",
  tags: {
    "__string" => "__string",
  },
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.last_updated_timestamp #=> String
resp.latest_version #=> String
resp.latest_version_arn #=> String
resp.name #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :initial_version (Types::LoggerDefinitionVersion) —

    Information about a logger definition version.

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

    The key-value pair for the resource tag.

Returns:

See Also:



1295
1296
1297
1298
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1295

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

#create_logger_definition_version(params = {}) ⇒ Types::CreateLoggerDefinitionVersionResponse

Creates a version of a logger definition that has already been defined.

Examples:

Request syntax with placeholder values


resp = client.create_logger_definition_version({
  amzn_client_token: "__string",
  logger_definition_id: "__string", # required
  loggers: [
    {
      component: "GreengrassSystem", # required, accepts GreengrassSystem, Lambda
      id: "__string", # required
      level: "DEBUG", # required, accepts DEBUG, INFO, WARN, ERROR, FATAL
      space: 1,
      type: "FileSystem", # required, accepts FileSystem, AWSCloudWatch
    },
  ],
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :logger_definition_id (required, String)
  • :loggers (Array<Types::Logger>)

Returns:

See Also:



1343
1344
1345
1346
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1343

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

#create_resource_definition(params = {}) ⇒ Types::CreateResourceDefinitionResponse

Creates a resource definition which contains a list of resources to be used in a group. You can create an initial version of the definition by providing a list of resources now, or use ”CreateResourceDefinitionVersion” later.

Examples:

Request syntax with placeholder values


resp = client.create_resource_definition({
  amzn_client_token: "__string",
  initial_version: {
    resources: [
      {
        id: "__string", # required
        name: "__string", # required
        resource_data_container: { # required
          local_device_resource_data: {
            group_owner_setting: {
              auto_add_group_owner: false,
              group_owner: "__string",
            },
            source_path: "__string",
          },
          local_volume_resource_data: {
            destination_path: "__string",
            group_owner_setting: {
              auto_add_group_owner: false,
              group_owner: "__string",
            },
            source_path: "__string",
          },
          s3_machine_learning_model_resource_data: {
            destination_path: "__string",
            owner_setting: {
              group_owner: "__string", # required
              group_permission: "ro", # required, accepts ro, rw
            },
            s3_uri: "__string",
          },
          sage_maker_machine_learning_model_resource_data: {
            destination_path: "__string",
            owner_setting: {
              group_owner: "__string", # required
              group_permission: "ro", # required, accepts ro, rw
            },
            sage_maker_job_arn: "__string",
          },
          secrets_manager_secret_resource_data: {
            arn: "__string",
            additional_staging_labels_to_download: ["__string"],
          },
        },
      },
    ],
  },
  name: "__string",
  tags: {
    "__string" => "__string",
  },
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.last_updated_timestamp #=> String
resp.latest_version #=> String
resp.latest_version_arn #=> String
resp.name #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :initial_version (Types::ResourceDefinitionVersion) —

    Information about a resource definition version.

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

    The key-value pair for the resource tag.

Returns:

See Also:



1442
1443
1444
1445
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1442

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

#create_resource_definition_version(params = {}) ⇒ Types::CreateResourceDefinitionVersionResponse

Creates a version of a resource definition that has already been defined.

Examples:

Request syntax with placeholder values


resp = client.create_resource_definition_version({
  amzn_client_token: "__string",
  resource_definition_id: "__string", # required
  resources: [
    {
      id: "__string", # required
      name: "__string", # required
      resource_data_container: { # required
        local_device_resource_data: {
          group_owner_setting: {
            auto_add_group_owner: false,
            group_owner: "__string",
          },
          source_path: "__string",
        },
        local_volume_resource_data: {
          destination_path: "__string",
          group_owner_setting: {
            auto_add_group_owner: false,
            group_owner: "__string",
          },
          source_path: "__string",
        },
        s3_machine_learning_model_resource_data: {
          destination_path: "__string",
          owner_setting: {
            group_owner: "__string", # required
            group_permission: "ro", # required, accepts ro, rw
          },
          s3_uri: "__string",
        },
        sage_maker_machine_learning_model_resource_data: {
          destination_path: "__string",
          owner_setting: {
            group_owner: "__string", # required
            group_permission: "ro", # required, accepts ro, rw
          },
          sage_maker_job_arn: "__string",
        },
        secrets_manager_secret_resource_data: {
          arn: "__string",
          additional_staging_labels_to_download: ["__string"],
        },
      },
    },
  ],
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :resource_definition_id (required, String)
  • :resources (Array<Types::Resource>)

Returns:

See Also:



1524
1525
1526
1527
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1524

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

#create_software_update_job(params = {}) ⇒ Types::CreateSoftwareUpdateJobResponse

Creates a software update for a core or group of cores (specified as an IoT thing group.) Use this to update the OTA Agent as well as the Greengrass core software. It makes use of the IoT Jobs feature which provides additional commands to manage a Greengrass core software update job.

Examples:

Request syntax with placeholder values


resp = client.create_software_update_job({
  amzn_client_token: "__string",
  s3_url_signer_role: "S3UrlSignerRole", # required
  software_to_update: "core", # required, accepts core, ota_agent
  update_agent_log_level: "NONE", # accepts NONE, TRACE, DEBUG, VERBOSE, INFO, WARN, ERROR, FATAL
  update_targets: ["__string"], # required
  update_targets_architecture: "armv6l", # required, accepts armv6l, armv7l, x86_64, aarch64
  update_targets_operating_system: "ubuntu", # required, accepts ubuntu, raspbian, amazon_linux, openwrt
})

Response structure


resp.iot_job_arn #=> String
resp.iot_job_id #=> String
resp.platform_software_version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :s3_url_signer_role (required, String) —

    The IAM Role that Greengrass will use to create pre-signed URLs pointing towards the update artifact.

  • :software_to_update (required, String) —

    The piece of software on the Greengrass core that will be updated.

  • :update_agent_log_level (String) —

    The minimum level of log statements that should be logged by the OTA Agent during an update.

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

    The ARNs of the targets (IoT things or IoT thing groups) that this update will be applied to.

  • :update_targets_architecture (required, String) —

    The architecture of the cores which are the targets of an update.

  • :update_targets_operating_system (required, String) —

    The operating system of the cores which are the targets of an update.

Returns:

See Also:



1586
1587
1588
1589
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1586

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

#create_subscription_definition(params = {}) ⇒ Types::CreateSubscriptionDefinitionResponse

Creates a subscription definition. You may provide the initial version of the subscription definition now or use ”CreateSubscriptionDefinitionVersion” at a later time.

Examples:

Request syntax with placeholder values


resp = client.create_subscription_definition({
  amzn_client_token: "__string",
  initial_version: {
    subscriptions: [
      {
        id: "__string", # required
        source: "__string", # required
        subject: "__string", # required
        target: "__string", # required
      },
    ],
  },
  name: "__string",
  tags: {
    "__string" => "__string",
  },
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.last_updated_timestamp #=> String
resp.latest_version #=> String
resp.latest_version_arn #=> String
resp.name #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :initial_version (Types::SubscriptionDefinitionVersion) —

    Information about a subscription definition version.

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

    The key-value pair for the resource tag.

Returns:

See Also:



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

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

#create_subscription_definition_version(params = {}) ⇒ Types::CreateSubscriptionDefinitionVersionResponse

Creates a version of a subscription definition which has already been defined.

Examples:

Request syntax with placeholder values


resp = client.create_subscription_definition_version({
  amzn_client_token: "__string",
  subscription_definition_id: "__string", # required
  subscriptions: [
    {
      id: "__string", # required
      source: "__string", # required
      subject: "__string", # required
      target: "__string", # required
    },
  ],
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :subscription_definition_id (required, String)
  • :subscriptions (Array<Types::Subscription>)

Returns:

See Also:



1696
1697
1698
1699
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1696

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

#delete_connector_definition(params = {}) ⇒ Struct

Deletes a connector definition.

Examples:

Request syntax with placeholder values


resp = client.delete_connector_definition({
  connector_definition_id: "__string", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :connector_definition_id (required, String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



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

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

#delete_core_definition(params = {}) ⇒ Struct

Deletes a core definition.

Examples:

Request syntax with placeholder values


resp = client.delete_core_definition({
  core_definition_id: "__string", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :core_definition_id (required, String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1738
1739
1740
1741
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1738

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

#delete_device_definition(params = {}) ⇒ Struct

Deletes a device definition.

Examples:

Request syntax with placeholder values


resp = client.delete_device_definition({
  device_definition_id: "__string", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :device_definition_id (required, String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1759
1760
1761
1762
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1759

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

#delete_function_definition(params = {}) ⇒ Struct

Deletes a Lambda function definition.

Examples:

Request syntax with placeholder values


resp = client.delete_function_definition({
  function_definition_id: "__string", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :function_definition_id (required, String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1780
1781
1782
1783
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1780

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

#delete_group(params = {}) ⇒ Struct

Deletes a group.

Examples:

Request syntax with placeholder values


resp = client.delete_group({
  group_id: "__string", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :group_id (required, String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1801
1802
1803
1804
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1801

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

#delete_logger_definition(params = {}) ⇒ Struct

Deletes a logger definition.

Examples:

Request syntax with placeholder values


resp = client.delete_logger_definition({
  logger_definition_id: "__string", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :logger_definition_id (required, String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1822
1823
1824
1825
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1822

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

#delete_resource_definition(params = {}) ⇒ Struct

Deletes a resource definition.

Examples:

Request syntax with placeholder values


resp = client.delete_resource_definition({
  resource_definition_id: "__string", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :resource_definition_id (required, String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1843
1844
1845
1846
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1843

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

#delete_subscription_definition(params = {}) ⇒ Struct

Deletes a subscription definition.

Examples:

Request syntax with placeholder values


resp = client.delete_subscription_definition({
  subscription_definition_id: "__string", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :subscription_definition_id (required, String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1864
1865
1866
1867
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1864

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

#disassociate_role_from_group(params = {}) ⇒ Types::DisassociateRoleFromGroupResponse

Disassociates the role from a group.

Examples:

Request syntax with placeholder values


resp = client.disassociate_role_from_group({
  group_id: "__string", # required
})

Response structure


resp.disassociated_at #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :group_id (required, String)

Returns:

See Also:



1891
1892
1893
1894
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1891

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

#disassociate_service_role_from_account(params = {}) ⇒ Types::DisassociateServiceRoleFromAccountResponse

Disassociates the service role from your account. Without a service role, deployments will not work.

Examples:

Response structure


resp.disassociated_at #=> String

Parameters:

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

    ({})

Returns:

See Also:



1911
1912
1913
1914
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1911

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

#get_associated_role(params = {}) ⇒ Types::GetAssociatedRoleResponse

Retrieves the role associated with a particular group.

Examples:

Request syntax with placeholder values


resp = client.get_associated_role({
  group_id: "__string", # required
})

Response structure


resp.associated_at #=> String
resp.role_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :group_id (required, String)

Returns:

See Also:



1940
1941
1942
1943
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1940

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

#get_bulk_deployment_status(params = {}) ⇒ Types::GetBulkDeploymentStatusResponse

Returns the status of a bulk deployment.

Examples:

Request syntax with placeholder values


resp = client.get_bulk_deployment_status({
  bulk_deployment_id: "__string", # required
})

Response structure


resp.bulk_deployment_metrics.invalid_input_records #=> Integer
resp.bulk_deployment_metrics.records_processed #=> Integer
resp.bulk_deployment_metrics.retry_attempts #=> Integer
resp.bulk_deployment_status #=> String, one of "Initializing", "Running", "Completed", "Stopping", "Stopped", "Failed"
resp.created_at #=> String
resp.error_details #=> Array
resp.error_details[0].detailed_error_code #=> String
resp.error_details[0].detailed_error_message #=> String
resp.error_message #=> String
resp.tags #=> Hash
resp.tags["__string"] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :bulk_deployment_id (required, String)

Returns:

See Also:



1982
1983
1984
1985
 
# File 'lib/aws-sdk-greengrass/client.rb', line 1982

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

#get_connectivity_info(params = {}) ⇒ Types::GetConnectivityInfoResponse

Retrieves the connectivity information for a core.

Examples:

Request syntax with placeholder values


resp = client.get_connectivity_info({
  thing_name: "__string", # required
})

Response structure


resp.connectivity_info #=> Array
resp.connectivity_info[0].host_address #=> String
resp.connectivity_info[0].id #=> String
resp.connectivity_info[0].metadata #=> String
resp.connectivity_info[0].port_number #=> Integer
resp.message #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :thing_name (required, String)

Returns:

See Also:



2015
2016
2017
2018
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2015

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

#get_connector_definition(params = {}) ⇒ Types::GetConnectorDefinitionResponse

Retrieves information about a connector definition.

Examples:

Request syntax with placeholder values


resp = client.get_connector_definition({
  connector_definition_id: "__string", # required
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.last_updated_timestamp #=> String
resp.latest_version #=> String
resp.latest_version_arn #=> String
resp.name #=> String
resp.tags #=> Hash
resp.tags["__string"] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :connector_definition_id (required, String)

Returns:

See Also:



2057
2058
2059
2060
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2057

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

#get_connector_definition_version(params = {}) ⇒ Types::GetConnectorDefinitionVersionResponse

Retrieves information about a connector definition version, including the connectors that the version contains. Connectors are prebuilt modules that interact with local infrastructure, device protocols, AWS, and other cloud services.

Examples:

Request syntax with placeholder values


resp = client.get_connector_definition_version({
  connector_definition_id: "__string", # required
  connector_definition_version_id: "__string", # required
  next_token: "__string",
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.definition.connectors #=> Array
resp.definition.connectors[0].connector_arn #=> String
resp.definition.connectors[0].id #=> String
resp.definition.connectors[0].parameters #=> Hash
resp.definition.connectors[0].parameters["__string"] #=> String
resp.id #=> String
resp.next_token #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :connector_definition_id (required, String)
  • :connector_definition_version_id (required, String)
  • :next_token (String)

Returns:

See Also:



2107
2108
2109
2110
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2107

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

#get_core_definition(params = {}) ⇒ Types::GetCoreDefinitionResponse

Retrieves information about a core definition version.

Examples:

Request syntax with placeholder values


resp = client.get_core_definition({
  core_definition_id: "__string", # required
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.last_updated_timestamp #=> String
resp.latest_version #=> String
resp.latest_version_arn #=> String
resp.name #=> String
resp.tags #=> Hash
resp.tags["__string"] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :core_definition_id (required, String)

Returns:

See Also:



2149
2150
2151
2152
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2149

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

#get_core_definition_version(params = {}) ⇒ Types::GetCoreDefinitionVersionResponse

Retrieves information about a core definition version.

Examples:

Request syntax with placeholder values


resp = client.get_core_definition_version({
  core_definition_id: "__string", # required
  core_definition_version_id: "__string", # required
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.definition.cores #=> Array
resp.definition.cores[0].certificate_arn #=> String
resp.definition.cores[0].id #=> String
resp.definition.cores[0].sync_shadow #=> Boolean
resp.definition.cores[0].thing_arn #=> String
resp.id #=> String
resp.next_token #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :core_definition_id (required, String)
  • :core_definition_version_id (required, String)

Returns:

See Also:



2193
2194
2195
2196
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2193

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

#get_deployment_status(params = {}) ⇒ Types::GetDeploymentStatusResponse

Returns the status of a deployment.

Examples:

Request syntax with placeholder values


resp = client.get_deployment_status({
  deployment_id: "__string", # required
  group_id: "__string", # required
})

Response structure


resp.deployment_status #=> String
resp.deployment_type #=> String, one of "NewDeployment", "Redeployment", "ResetDeployment", "ForceResetDeployment"
resp.error_details #=> Array
resp.error_details[0].detailed_error_code #=> String
resp.error_details[0].detailed_error_message #=> String
resp.error_message #=> String
resp.updated_at #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :deployment_id (required, String)
  • :group_id (required, String)

Returns:

See Also:



2233
2234
2235
2236
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2233

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

#get_device_definition(params = {}) ⇒ Types::GetDeviceDefinitionResponse

Retrieves information about a device definition.

Examples:

Request syntax with placeholder values


resp = client.get_device_definition({
  device_definition_id: "__string", # required
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.last_updated_timestamp #=> String
resp.latest_version #=> String
resp.latest_version_arn #=> String
resp.name #=> String
resp.tags #=> Hash
resp.tags["__string"] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :device_definition_id (required, String)

Returns:

See Also:



2275
2276
2277
2278
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2275

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

#get_device_definition_version(params = {}) ⇒ Types::GetDeviceDefinitionVersionResponse

Retrieves information about a device definition version.

Examples:

Request syntax with placeholder values


resp = client.get_device_definition_version({
  device_definition_id: "__string", # required
  device_definition_version_id: "__string", # required
  next_token: "__string",
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.definition.devices #=> Array
resp.definition.devices[0].certificate_arn #=> String
resp.definition.devices[0].id #=> String
resp.definition.devices[0].sync_shadow #=> Boolean
resp.definition.devices[0].thing_arn #=> String
resp.id #=> String
resp.next_token #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :device_definition_id (required, String)
  • :device_definition_version_id (required, String)
  • :next_token (String)

Returns:

See Also:



2322
2323
2324
2325
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2322

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

#get_function_definition(params = {}) ⇒ Types::GetFunctionDefinitionResponse

Retrieves information about a Lambda function definition, including its creation time and latest version.

Examples:

Request syntax with placeholder values


resp = client.get_function_definition({
  function_definition_id: "__string", # required
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.last_updated_timestamp #=> String
resp.latest_version #=> String
resp.latest_version_arn #=> String
resp.name #=> String
resp.tags #=> Hash
resp.tags["__string"] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :function_definition_id (required, String)

Returns:

See Also:



2365
2366
2367
2368
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2365

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

#get_function_definition_version(params = {}) ⇒ Types::GetFunctionDefinitionVersionResponse

Retrieves information about a Lambda function definition version, including which Lambda functions are included in the version and their configurations.

Examples:

Request syntax with placeholder values


resp = client.get_function_definition_version({
  function_definition_id: "__string", # required
  function_definition_version_id: "__string", # required
  next_token: "__string",
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.definition.default_config.execution.isolation_mode #=> String, one of "GreengrassContainer", "NoContainer"
resp.definition.default_config.execution.run_as.gid #=> Integer
resp.definition.default_config.execution.run_as.uid #=> Integer
resp.definition.functions #=> Array
resp.definition.functions[0].function_arn #=> String
resp.definition.functions[0].function_configuration.encoding_type #=> String, one of "binary", "json"
resp.definition.functions[0].function_configuration.environment.access_sysfs #=> Boolean
resp.definition.functions[0].function_configuration.environment.execution.isolation_mode #=> String, one of "GreengrassContainer", "NoContainer"
resp.definition.functions[0].function_configuration.environment.execution.run_as.gid #=> Integer
resp.definition.functions[0].function_configuration.environment.execution.run_as.uid #=> Integer
resp.definition.functions[0].function_configuration.environment.resource_access_policies #=> Array
resp.definition.functions[0].function_configuration.environment.resource_access_policies[0].permission #=> String, one of "ro", "rw"
resp.definition.functions[0].function_configuration.environment.resource_access_policies[0].resource_id #=> String
resp.definition.functions[0].function_configuration.environment.variables #=> Hash
resp.definition.functions[0].function_configuration.environment.variables["__string"] #=> String
resp.definition.functions[0].function_configuration.exec_args #=> String
resp.definition.functions[0].function_configuration.executable #=> String
resp.definition.functions[0].function_configuration.memory_size #=> Integer
resp.definition.functions[0].function_configuration.pinned #=> Boolean
resp.definition.functions[0].function_configuration.timeout #=> Integer
resp.definition.functions[0].function_configuration.function_runtime_override #=> String
resp.definition.functions[0].id #=> String
resp.id #=> String
resp.next_token #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :function_definition_id (required, String)
  • :function_definition_version_id (required, String)
  • :next_token (String)

Returns:

See Also:



2431
2432
2433
2434
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2431

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

#get_group(params = {}) ⇒ Types::GetGroupResponse

Retrieves information about a group.

Examples:

Request syntax with placeholder values


resp = client.get_group({
  group_id: "__string", # required
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.last_updated_timestamp #=> String
resp.latest_version #=> String
resp.latest_version_arn #=> String
resp.name #=> String
resp.tags #=> Hash
resp.tags["__string"] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :group_id (required, String)

Returns:

See Also:



2473
2474
2475
2476
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2473

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

#get_group_certificate_authority(params = {}) ⇒ Types::GetGroupCertificateAuthorityResponse

Retreives the CA associated with a group. Returns the public key of the CA.

Examples:

Request syntax with placeholder values


resp = client.get_group_certificate_authority({
  certificate_authority_id: "__string", # required
  group_id: "__string", # required
})

Response structure


resp.group_certificate_authority_arn #=> String
resp.group_certificate_authority_id #=> String
resp.pem_encoded_certificate #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :certificate_authority_id (required, String)
  • :group_id (required, String)

Returns:

See Also:



2508
2509
2510
2511
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2508

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

#get_group_certificate_configuration(params = {}) ⇒ Types::GetGroupCertificateConfigurationResponse

Retrieves the current configuration for the CA used by the group.

Examples:

Request syntax with placeholder values


resp = client.get_group_certificate_configuration({
  group_id: "__string", # required
})

Response structure


resp.certificate_authority_expiry_in_milliseconds #=> String
resp.certificate_expiry_in_milliseconds #=> String
resp.group_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :group_id (required, String)

Returns:

See Also:



2539
2540
2541
2542
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2539

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

#get_group_version(params = {}) ⇒ Types::GetGroupVersionResponse

Retrieves information about a group version.

Examples:

Request syntax with placeholder values


resp = client.get_group_version({
  group_id: "__string", # required
  group_version_id: "__string", # required
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.definition.connector_definition_version_arn #=> String
resp.definition.core_definition_version_arn #=> String
resp.definition.device_definition_version_arn #=> String
resp.definition.function_definition_version_arn #=> String
resp.definition.logger_definition_version_arn #=> String
resp.definition.resource_definition_version_arn #=> String
resp.definition.subscription_definition_version_arn #=> String
resp.id #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :group_id (required, String)
  • :group_version_id (required, String)

Returns:

See Also:



2583
2584
2585
2586
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2583

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

#get_logger_definition(params = {}) ⇒ Types::GetLoggerDefinitionResponse

Retrieves information about a logger definition.

Examples:

Request syntax with placeholder values


resp = client.get_logger_definition({
  logger_definition_id: "__string", # required
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.last_updated_timestamp #=> String
resp.latest_version #=> String
resp.latest_version_arn #=> String
resp.name #=> String
resp.tags #=> Hash
resp.tags["__string"] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :logger_definition_id (required, String)

Returns:

See Also:



2625
2626
2627
2628
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2625

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

#get_logger_definition_version(params = {}) ⇒ Types::GetLoggerDefinitionVersionResponse

Retrieves information about a logger definition version.

Examples:

Request syntax with placeholder values


resp = client.get_logger_definition_version({
  logger_definition_id: "__string", # required
  logger_definition_version_id: "__string", # required
  next_token: "__string",
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.definition.loggers #=> Array
resp.definition.loggers[0].component #=> String, one of "GreengrassSystem", "Lambda"
resp.definition.loggers[0].id #=> String
resp.definition.loggers[0].level #=> String, one of "DEBUG", "INFO", "WARN", "ERROR", "FATAL"
resp.definition.loggers[0].space #=> Integer
resp.definition.loggers[0].type #=> String, one of "FileSystem", "AWSCloudWatch"
resp.id #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :logger_definition_id (required, String)
  • :logger_definition_version_id (required, String)
  • :next_token (String)

Returns:

See Also:



2671
2672
2673
2674
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2671

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

#get_resource_definition(params = {}) ⇒ Types::GetResourceDefinitionResponse

Retrieves information about a resource definition, including its creation time and latest version.

Examples:

Request syntax with placeholder values


resp = client.get_resource_definition({
  resource_definition_id: "__string", # required
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.last_updated_timestamp #=> String
resp.latest_version #=> String
resp.latest_version_arn #=> String
resp.name #=> String
resp.tags #=> Hash
resp.tags["__string"] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :resource_definition_id (required, String)

Returns:

See Also:



2714
2715
2716
2717
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2714

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

#get_resource_definition_version(params = {}) ⇒ Types::GetResourceDefinitionVersionResponse

Retrieves information about a resource definition version, including which resources are included in the version.

Examples:

Request syntax with placeholder values


resp = client.get_resource_definition_version({
  resource_definition_id: "__string", # required
  resource_definition_version_id: "__string", # required
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.definition.resources #=> Array
resp.definition.resources[0].id #=> String
resp.definition.resources[0].name #=> String
resp.definition.resources[0].resource_data_container.local_device_resource_data.group_owner_setting.auto_add_group_owner #=> Boolean
resp.definition.resources[0].resource_data_container.local_device_resource_data.group_owner_setting.group_owner #=> String
resp.definition.resources[0].resource_data_container.local_device_resource_data.source_path #=> String
resp.definition.resources[0].resource_data_container.local_volume_resource_data.destination_path #=> String
resp.definition.resources[0].resource_data_container.local_volume_resource_data.group_owner_setting.auto_add_group_owner #=> Boolean
resp.definition.resources[0].resource_data_container.local_volume_resource_data.group_owner_setting.group_owner #=> String
resp.definition.resources[0].resource_data_container.local_volume_resource_data.source_path #=> String
resp.definition.resources[0].resource_data_container.s3_machine_learning_model_resource_data.destination_path #=> String
resp.definition.resources[0].resource_data_container.s3_machine_learning_model_resource_data.owner_setting.group_owner #=> String
resp.definition.resources[0].resource_data_container.s3_machine_learning_model_resource_data.owner_setting.group_permission #=> String, one of "ro", "rw"
resp.definition.resources[0].resource_data_container.s3_machine_learning_model_resource_data.s3_uri #=> String
resp.definition.resources[0].resource_data_container.sage_maker_machine_learning_model_resource_data.destination_path #=> String
resp.definition.resources[0].resource_data_container.sage_maker_machine_learning_model_resource_data.owner_setting.group_owner #=> String
resp.definition.resources[0].resource_data_container.sage_maker_machine_learning_model_resource_data.owner_setting.group_permission #=> String, one of "ro", "rw"
resp.definition.resources[0].resource_data_container.sage_maker_machine_learning_model_resource_data.sage_maker_job_arn #=> String
resp.definition.resources[0].resource_data_container.secrets_manager_secret_resource_data.arn #=> String
resp.definition.resources[0].resource_data_container.secrets_manager_secret_resource_data.additional_staging_labels_to_download #=> Array
resp.definition.resources[0].resource_data_container.secrets_manager_secret_resource_data.additional_staging_labels_to_download[0] #=> String
resp.id #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :resource_definition_id (required, String)
  • :resource_definition_version_id (required, String)

Returns:

See Also:



2773
2774
2775
2776
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2773

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

#get_service_role_for_account(params = {}) ⇒ Types::GetServiceRoleForAccountResponse

Retrieves the service role that is attached to your account.

Examples:

Response structure


resp.associated_at #=> String
resp.role_arn #=> String

Parameters:

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

    ({})

Returns:

See Also:



2794
2795
2796
2797
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2794

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

#get_subscription_definition(params = {}) ⇒ Types::GetSubscriptionDefinitionResponse

Retrieves information about a subscription definition.

Examples:

Request syntax with placeholder values


resp = client.get_subscription_definition({
  subscription_definition_id: "__string", # required
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.id #=> String
resp.last_updated_timestamp #=> String
resp.latest_version #=> String
resp.latest_version_arn #=> String
resp.name #=> String
resp.tags #=> Hash
resp.tags["__string"] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :subscription_definition_id (required, String)

Returns:

See Also:



2836
2837
2838
2839
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2836

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

#get_subscription_definition_version(params = {}) ⇒ Types::GetSubscriptionDefinitionVersionResponse

Retrieves information about a subscription definition version.

Examples:

Request syntax with placeholder values


resp = client.get_subscription_definition_version({
  next_token: "__string",
  subscription_definition_id: "__string", # required
  subscription_definition_version_id: "__string", # required
})

Response structure


resp.arn #=> String
resp.creation_timestamp #=> String
resp.definition.subscriptions #=> Array
resp.definition.subscriptions[0].id #=> String
resp.definition.subscriptions[0].source #=> String
resp.definition.subscriptions[0].subject #=> String
resp.definition.subscriptions[0].target #=> String
resp.id #=> String
resp.next_token #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :next_token (String)
  • :subscription_definition_id (required, String)
  • :subscription_definition_version_id (required, String)

Returns:

See Also:



2883
2884
2885
2886
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2883

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

#get_thing_runtime_configuration(params = {}) ⇒ Types::GetThingRuntimeConfigurationResponse

Get the runtime configuration of a thing.

Examples:

Request syntax with placeholder values


resp = client.get_thing_runtime_configuration({
  thing_name: "__string", # required
})

Response structure


resp.runtime_configuration.telemetry_configuration.configuration_sync_status #=> String, one of "InSync", "OutOfSync"
resp.runtime_configuration.telemetry_configuration.telemetry #=> String, one of "On", "Off"

Parameters:

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

    ({})

Options Hash (params):

  • :thing_name (required, String)

Returns:

See Also:



2911
2912
2913
2914
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2911

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

#list_bulk_deployment_detailed_reports(params = {}) ⇒ Types::ListBulkDeploymentDetailedReportsResponse

Gets a paginated list of the deployments that have been started in a bulk deployment operation, and their current deployment status.

Examples:

Request syntax with placeholder values


resp = client.list_bulk_deployment_detailed_reports({
  bulk_deployment_id: "__string", # required
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.deployments #=> Array
resp.deployments[0].created_at #=> String
resp.deployments[0].deployment_arn #=> String
resp.deployments[0].deployment_id #=> String
resp.deployments[0].deployment_status #=> String
resp.deployments[0].deployment_type #=> String, one of "NewDeployment", "Redeployment", "ResetDeployment", "ForceResetDeployment"
resp.deployments[0].error_details #=> Array
resp.deployments[0].error_details[0].detailed_error_code #=> String
resp.deployments[0].error_details[0].detailed_error_message #=> String
resp.deployments[0].error_message #=> String
resp.deployments[0].group_arn #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :bulk_deployment_id (required, String)
  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



2957
2958
2959
2960
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2957

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

#list_bulk_deployments(params = {}) ⇒ Types::ListBulkDeploymentsResponse

Returns a list of bulk deployments.

Examples:

Request syntax with placeholder values


resp = client.list_bulk_deployments({
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.bulk_deployments #=> Array
resp.bulk_deployments[0].bulk_deployment_arn #=> String
resp.bulk_deployments[0].bulk_deployment_id #=> String
resp.bulk_deployments[0].created_at #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



2992
2993
2994
2995
 
# File 'lib/aws-sdk-greengrass/client.rb', line 2992

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

#list_connector_definition_versions(params = {}) ⇒ Types::ListConnectorDefinitionVersionsResponse

Lists the versions of a connector definition, which are containers for connectors. Connectors run on the Greengrass core and contain built-in integration with local infrastructure, device protocols, AWS, and other cloud services.

Examples:

Request syntax with placeholder values


resp = client.list_connector_definition_versions({
  connector_definition_id: "__string", # required
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.next_token #=> String
resp.versions #=> Array
resp.versions[0].arn #=> String
resp.versions[0].creation_timestamp #=> String
resp.versions[0].id #=> String
resp.versions[0].version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :connector_definition_id (required, String)
  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



3034
3035
3036
3037
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3034

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

#list_connector_definitions(params = {}) ⇒ Types::ListConnectorDefinitionsResponse

Retrieves a list of connector definitions.

Examples:

Request syntax with placeholder values


resp = client.list_connector_definitions({
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.definitions #=> Array
resp.definitions[0].arn #=> String
resp.definitions[0].creation_timestamp #=> String
resp.definitions[0].id #=> String
resp.definitions[0].last_updated_timestamp #=> String
resp.definitions[0].latest_version #=> String
resp.definitions[0].latest_version_arn #=> String
resp.definitions[0].name #=> String
resp.definitions[0].tags #=> Hash
resp.definitions[0].tags["__string"] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



3075
3076
3077
3078
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3075

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

#list_core_definition_versions(params = {}) ⇒ Types::ListCoreDefinitionVersionsResponse

Lists the versions of a core definition.

Examples:

Request syntax with placeholder values


resp = client.list_core_definition_versions({
  core_definition_id: "__string", # required
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.next_token #=> String
resp.versions #=> Array
resp.versions[0].arn #=> String
resp.versions[0].creation_timestamp #=> String
resp.versions[0].id #=> String
resp.versions[0].version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :core_definition_id (required, String)
  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



3114
3115
3116
3117
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3114

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

#list_core_definitions(params = {}) ⇒ Types::ListCoreDefinitionsResponse

Retrieves a list of core definitions.

Examples:

Request syntax with placeholder values


resp = client.list_core_definitions({
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.definitions #=> Array
resp.definitions[0].arn #=> String
resp.definitions[0].creation_timestamp #=> String
resp.definitions[0].id #=> String
resp.definitions[0].last_updated_timestamp #=> String
resp.definitions[0].latest_version #=> String
resp.definitions[0].latest_version_arn #=> String
resp.definitions[0].name #=> String
resp.definitions[0].tags #=> Hash
resp.definitions[0].tags["__string"] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



3155
3156
3157
3158
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3155

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

#list_deployments(params = {}) ⇒ Types::ListDeploymentsResponse

Returns a history of deployments for the group.

Examples:

Request syntax with placeholder values


resp = client.list_deployments({
  group_id: "__string", # required
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.deployments #=> Array
resp.deployments[0].created_at #=> String
resp.deployments[0].deployment_arn #=> String
resp.deployments[0].deployment_id #=> String
resp.deployments[0].deployment_type #=> String, one of "NewDeployment", "Redeployment", "ResetDeployment", "ForceResetDeployment"
resp.deployments[0].group_arn #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :group_id (required, String)
  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



3195
3196
3197
3198
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3195

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

#list_device_definition_versions(params = {}) ⇒ Types::ListDeviceDefinitionVersionsResponse

Lists the versions of a device definition.

Examples:

Request syntax with placeholder values


resp = client.list_device_definition_versions({
  device_definition_id: "__string", # required
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.next_token #=> String
resp.versions #=> Array
resp.versions[0].arn #=> String
resp.versions[0].creation_timestamp #=> String
resp.versions[0].id #=> String
resp.versions[0].version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :device_definition_id (required, String)
  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



3234
3235
3236
3237
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3234

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

#list_device_definitions(params = {}) ⇒ Types::ListDeviceDefinitionsResponse

Retrieves a list of device definitions.

Examples:

Request syntax with placeholder values


resp = client.list_device_definitions({
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.definitions #=> Array
resp.definitions[0].arn #=> String
resp.definitions[0].creation_timestamp #=> String
resp.definitions[0].id #=> String
resp.definitions[0].last_updated_timestamp #=> String
resp.definitions[0].latest_version #=> String
resp.definitions[0].latest_version_arn #=> String
resp.definitions[0].name #=> String
resp.definitions[0].tags #=> Hash
resp.definitions[0].tags["__string"] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



3275
3276
3277
3278
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3275

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

#list_function_definition_versions(params = {}) ⇒ Types::ListFunctionDefinitionVersionsResponse

Lists the versions of a Lambda function definition.

Examples:

Request syntax with placeholder values


resp = client.list_function_definition_versions({
  function_definition_id: "__string", # required
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.next_token #=> String
resp.versions #=> Array
resp.versions[0].arn #=> String
resp.versions[0].creation_timestamp #=> String
resp.versions[0].id #=> String
resp.versions[0].version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :function_definition_id (required, String)
  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



3314
3315
3316
3317
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3314

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

#list_function_definitions(params = {}) ⇒ Types::ListFunctionDefinitionsResponse

Retrieves a list of Lambda function definitions.

Examples:

Request syntax with placeholder values


resp = client.list_function_definitions({
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.definitions #=> Array
resp.definitions[0].arn #=> String
resp.definitions[0].creation_timestamp #=> String
resp.definitions[0].id #=> String
resp.definitions[0].last_updated_timestamp #=> String
resp.definitions[0].latest_version #=> String
resp.definitions[0].latest_version_arn #=> String
resp.definitions[0].name #=> String
resp.definitions[0].tags #=> Hash
resp.definitions[0].tags["__string"] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



3355
3356
3357
3358
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3355

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

#list_group_certificate_authorities(params = {}) ⇒ Types::ListGroupCertificateAuthoritiesResponse

Retrieves the current CAs for a group.

Examples:

Request syntax with placeholder values


resp = client.list_group_certificate_authorities({
  group_id: "__string", # required
})

Response structure


resp.group_certificate_authorities #=> Array
resp.group_certificate_authorities[0].group_certificate_authority_arn #=> String
resp.group_certificate_authorities[0].group_certificate_authority_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :group_id (required, String)

Returns:

See Also:



3384
3385
3386
3387
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3384

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

#list_group_versions(params = {}) ⇒ Types::ListGroupVersionsResponse

Lists the versions of a group.

Examples:

Request syntax with placeholder values


resp = client.list_group_versions({
  group_id: "__string", # required
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.next_token #=> String
resp.versions #=> Array
resp.versions[0].arn #=> String
resp.versions[0].creation_timestamp #=> String
resp.versions[0].id #=> String
resp.versions[0].version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :group_id (required, String)
  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



3423
3424
3425
3426
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3423

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

#list_groups(params = {}) ⇒ Types::ListGroupsResponse

Retrieves a list of groups.

Examples:

Request syntax with placeholder values


resp = client.list_groups({
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.groups #=> Array
resp.groups[0].arn #=> String
resp.groups[0].creation_timestamp #=> String
resp.groups[0].id #=> String
resp.groups[0].last_updated_timestamp #=> String
resp.groups[0].latest_version #=> String
resp.groups[0].latest_version_arn #=> String
resp.groups[0].name #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



3462
3463
3464
3465
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3462

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

#list_logger_definition_versions(params = {}) ⇒ Types::ListLoggerDefinitionVersionsResponse

Lists the versions of a logger definition.

Examples:

Request syntax with placeholder values


resp = client.list_logger_definition_versions({
  logger_definition_id: "__string", # required
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.next_token #=> String
resp.versions #=> Array
resp.versions[0].arn #=> String
resp.versions[0].creation_timestamp #=> String
resp.versions[0].id #=> String
resp.versions[0].version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :logger_definition_id (required, String)
  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



3501
3502
3503
3504
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3501

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

#list_logger_definitions(params = {}) ⇒ Types::ListLoggerDefinitionsResponse

Retrieves a list of logger definitions.

Examples:

Request syntax with placeholder values


resp = client.list_logger_definitions({
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.definitions #=> Array
resp.definitions[0].arn #=> String
resp.definitions[0].creation_timestamp #=> String
resp.definitions[0].id #=> String
resp.definitions[0].last_updated_timestamp #=> String
resp.definitions[0].latest_version #=> String
resp.definitions[0].latest_version_arn #=> String
resp.definitions[0].name #=> String
resp.definitions[0].tags #=> Hash
resp.definitions[0].tags["__string"] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



3542
3543
3544
3545
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3542

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

#list_resource_definition_versions(params = {}) ⇒ Types::ListResourceDefinitionVersionsResponse

Lists the versions of a resource definition.

Examples:

Request syntax with placeholder values


resp = client.list_resource_definition_versions({
  max_results: "__string",
  next_token: "__string",
  resource_definition_id: "__string", # required
})

Response structure


resp.next_token #=> String
resp.versions #=> Array
resp.versions[0].arn #=> String
resp.versions[0].creation_timestamp #=> String
resp.versions[0].id #=> String
resp.versions[0].version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (String)
  • :next_token (String)
  • :resource_definition_id (required, String)

Returns:

See Also:



3581
3582
3583
3584
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3581

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

#list_resource_definitions(params = {}) ⇒ Types::ListResourceDefinitionsResponse

Retrieves a list of resource definitions.

Examples:

Request syntax with placeholder values


resp = client.list_resource_definitions({
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.definitions #=> Array
resp.definitions[0].arn #=> String
resp.definitions[0].creation_timestamp #=> String
resp.definitions[0].id #=> String
resp.definitions[0].last_updated_timestamp #=> String
resp.definitions[0].latest_version #=> String
resp.definitions[0].latest_version_arn #=> String
resp.definitions[0].name #=> String
resp.definitions[0].tags #=> Hash
resp.definitions[0].tags["__string"] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



3622
3623
3624
3625
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3622

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

#list_subscription_definition_versions(params = {}) ⇒ Types::ListSubscriptionDefinitionVersionsResponse

Lists the versions of a subscription definition.

Examples:

Request syntax with placeholder values


resp = client.list_subscription_definition_versions({
  max_results: "__string",
  next_token: "__string",
  subscription_definition_id: "__string", # required
})

Response structure


resp.next_token #=> String
resp.versions #=> Array
resp.versions[0].arn #=> String
resp.versions[0].creation_timestamp #=> String
resp.versions[0].id #=> String
resp.versions[0].version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (String)
  • :next_token (String)
  • :subscription_definition_id (required, String)

Returns:

See Also:



3661
3662
3663
3664
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3661

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

#list_subscription_definitions(params = {}) ⇒ Types::ListSubscriptionDefinitionsResponse

Retrieves a list of subscription definitions.

Examples:

Request syntax with placeholder values


resp = client.list_subscription_definitions({
  max_results: "__string",
  next_token: "__string",
})

Response structure


resp.definitions #=> Array
resp.definitions[0].arn #=> String
resp.definitions[0].creation_timestamp #=> String
resp.definitions[0].id #=> String
resp.definitions[0].last_updated_timestamp #=> String
resp.definitions[0].latest_version #=> String
resp.definitions[0].latest_version_arn #=> String
resp.definitions[0].name #=> String
resp.definitions[0].tags #=> Hash
resp.definitions[0].tags["__string"] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (String)
  • :next_token (String)

Returns:

See Also:



3702
3703
3704
3705
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3702

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

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

Retrieves a list of resource tags for a resource arn.

Examples:

Request syntax with placeholder values


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

Response structure


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

Parameters:

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

    ({})

Options Hash (params):

  • :resource_arn (required, String)

Returns:

See Also:



3730
3731
3732
3733
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3730

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

#reset_deployments(params = {}) ⇒ Types::ResetDeploymentsResponse

Resets a group’s deployments.

Examples:

Request syntax with placeholder values


resp = client.reset_deployments({
  amzn_client_token: "__string",
  force: false,
  group_id: "__string", # required
})

Response structure


resp.deployment_arn #=> String
resp.deployment_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :force (Boolean) —

    If true, performs a best-effort only core reset.

  • :group_id (required, String)

Returns:

See Also:



3766
3767
3768
3769
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3766

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

#start_bulk_deployment(params = {}) ⇒ Types::StartBulkDeploymentResponse

Deploys multiple groups in one operation. This action starts the bulk deployment of a specified set of group versions. Each group version deployment will be triggered with an adaptive rate that has a fixed upper limit. We recommend that you include an ”X-Amzn-Client-Token” token in every ”StartBulkDeployment” request. These requests are idempotent with respect to the token and the request parameters.

Examples:

Request syntax with placeholder values


resp = client.start_bulk_deployment({
  amzn_client_token: "__string",
  execution_role_arn: "__string", # required
  input_file_uri: "__string", # required
  tags: {
    "__string" => "__string",
  },
})

Response structure


resp.bulk_deployment_arn #=> String
resp.bulk_deployment_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :amzn_client_token (String)
  • :execution_role_arn (required, String) —

    The ARN of the execution role to associate with the bulk deployment operation. This IAM role must allow the ”greengrass:CreateDeployment” action for all group versions that are listed in the input file. This IAM role must have access to the S3 bucket containing the input file.

  • :input_file_uri (required, String) —

    The URI of the input file contained in the S3 bucket. The execution role must have ”getObject” permissions on this bucket to access the input file. The input file is a JSON-serialized, line delimited file with UTF-8 encoding that provides a list of group and version IDs and the deployment type. This file must be less than 100 MB. Currently, AWS IoT Greengrass supports only ”NewDeployment” deployment types.

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

    The key-value pair for the resource tag.

Returns:

See Also:



3825
3826
3827
3828
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3825

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

#stop_bulk_deployment(params = {}) ⇒ Struct

Stops the execution of a bulk deployment. This action returns a status of ”Stopping” until the deployment is stopped. You cannot start a new bulk deployment while a previous deployment is in the ”Stopping” state. This action doesn’t rollback completed deployments or cancel pending deployments.

Examples:

Request syntax with placeholder values


resp = client.stop_bulk_deployment({
  bulk_deployment_id: "__string", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :bulk_deployment_id (required, String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3850
3851
3852
3853
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3850

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

#tag_resource(params = {}) ⇒ Struct

Adds tags to a Greengrass resource. Valid resources are ‘Group’, ‘ConnectorDefinition’, ‘CoreDefinition’, ‘DeviceDefinition’, ‘FunctionDefinition’, ‘LoggerDefinition’, ‘SubscriptionDefinition’, ‘ResourceDefinition’, and ‘BulkDeployment’.

Examples:

Request syntax with placeholder values


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

Parameters:

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

    ({})

Options Hash (params):

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

    The key-value pair for the resource tag.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3881
3882
3883
3884
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3881

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

#untag_resource(params = {}) ⇒ Struct

Remove resource tags from a Greengrass Resource.

Examples:

Request syntax with placeholder values


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

Parameters:

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

    ({})

Options Hash (params):

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

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3905
3906
3907
3908
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3905

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

#update_connectivity_info(params = {}) ⇒ Types::UpdateConnectivityInfoResponse

Updates the connectivity information for the core. Any devices that belong to the group which has this core will receive this information in order to find the location of the core and connect to it.

Examples:

Request syntax with placeholder values


resp = client.update_connectivity_info({
  connectivity_info: [
    {
      host_address: "__string",
      id: "__string",
      metadata: "__string",
      port_number: 1,
    },
  ],
  thing_name: "__string", # required
})

Response structure


resp.message #=> String
resp.version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :connectivity_info (Array<Types::ConnectivityInfo>) —

    A list of connectivity info.

  • :thing_name (required, String)

Returns:

See Also:



3947
3948
3949
3950
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3947

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

#update_connector_definition(params = {}) ⇒ Struct

Updates a connector definition.

Examples:

Request syntax with placeholder values


resp = client.update_connector_definition({
  connector_definition_id: "__string", # required
  name: "__string",
})

Parameters:

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

    ({})

Options Hash (params):

  • :connector_definition_id (required, String)
  • :name (String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3971
3972
3973
3974
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3971

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

#update_core_definition(params = {}) ⇒ Struct

Updates a core definition.

Examples:

Request syntax with placeholder values


resp = client.update_core_definition({
  core_definition_id: "__string", # required
  name: "__string",
})

Parameters:

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

    ({})

Options Hash (params):

  • :core_definition_id (required, String)
  • :name (String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3995
3996
3997
3998
 
# File 'lib/aws-sdk-greengrass/client.rb', line 3995

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

#update_device_definition(params = {}) ⇒ Struct

Updates a device definition.

Examples:

Request syntax with placeholder values


resp = client.update_device_definition({
  device_definition_id: "__string", # required
  name: "__string",
})

Parameters:

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

    ({})

Options Hash (params):

  • :device_definition_id (required, String)
  • :name (String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



4019
4020
4021
4022
 
# File 'lib/aws-sdk-greengrass/client.rb', line 4019

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

#update_function_definition(params = {}) ⇒ Struct

Updates a Lambda function definition.

Examples:

Request syntax with placeholder values


resp = client.update_function_definition({
  function_definition_id: "__string", # required
  name: "__string",
})

Parameters:

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

    ({})

Options Hash (params):

  • :function_definition_id (required, String)
  • :name (String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



4043
4044
4045
4046
 
# File 'lib/aws-sdk-greengrass/client.rb', line 4043

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

#update_group(params = {}) ⇒ Struct

Updates a group.

Examples:

Request syntax with placeholder values


resp = client.update_group({
  group_id: "__string", # required
  name: "__string",
})

Parameters:

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

    ({})

Options Hash (params):

  • :group_id (required, String)
  • :name (String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



4067
4068
4069
4070
 
# File 'lib/aws-sdk-greengrass/client.rb', line 4067

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

#update_group_certificate_configuration(params = {}) ⇒ Types::UpdateGroupCertificateConfigurationResponse

Updates the Certificate expiry time for a group.

Examples:

Request syntax with placeholder values


resp = client.update_group_certificate_configuration({
  certificate_expiry_in_milliseconds: "__string",
  group_id: "__string", # required
})

Response structure


resp.certificate_authority_expiry_in_milliseconds #=> String
resp.certificate_expiry_in_milliseconds #=> String
resp.group_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :certificate_expiry_in_milliseconds (String) —

    The amount of time remaining before the certificate expires, in milliseconds.

  • :group_id (required, String)

Returns:

See Also:



4103
4104
4105
4106
 
# File 'lib/aws-sdk-greengrass/client.rb', line 4103

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

#update_logger_definition(params = {}) ⇒ Struct

Updates a logger definition.

Examples:

Request syntax with placeholder values


resp = client.update_logger_definition({
  logger_definition_id: "__string", # required
  name: "__string",
})

Parameters:

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

    ({})

Options Hash (params):

  • :logger_definition_id (required, String)
  • :name (String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



4127
4128
4129
4130
 
# File 'lib/aws-sdk-greengrass/client.rb', line 4127

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

#update_resource_definition(params = {}) ⇒ Struct

Updates a resource definition.

Examples:

Request syntax with placeholder values


resp = client.update_resource_definition({
  name: "__string",
  resource_definition_id: "__string", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :name (String)
  • :resource_definition_id (required, String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



4151
4152
4153
4154
 
# File 'lib/aws-sdk-greengrass/client.rb', line 4151

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

#update_subscription_definition(params = {}) ⇒ Struct

Updates a subscription definition.

Examples:

Request syntax with placeholder values


resp = client.update_subscription_definition({
  name: "__string",
  subscription_definition_id: "__string", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :name (String)
  • :subscription_definition_id (required, String)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



4175
4176
4177
4178
 
# File 'lib/aws-sdk-greengrass/client.rb', line 4175

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

#update_thing_runtime_configuration(params = {}) ⇒ Struct

Updates the runtime configuration of a thing.

Examples:

Request syntax with placeholder values


resp = client.update_thing_runtime_configuration({
  telemetry_configuration: {
    telemetry: "On", # required, accepts On, Off
  },
  thing_name: "__string", # required
})

Parameters:

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

    ({})

Options Hash (params):

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



4202
4203
4204
4205
 
# File 'lib/aws-sdk-greengrass/client.rb', line 4202

def update_thing_runtime_configuration(params = {}, options = {})
  req = build_request(:update_thing_runtime_configuration, 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. 


4231
4232
4233
 
# File 'lib/aws-sdk-greengrass/client.rb', line 4231

def waiter_names
  []
end