class Aws::KinesisAnalytics::Types::CreateApplicationRequest

TBD

@note When making an API call, you may pass CreateApplicationRequest

data as a hash:

    {
      application_name: "ApplicationName", # required
      application_description: "ApplicationDescription",
      inputs: [
        {
          name_prefix: "InAppStreamName", # required
          input_processing_configuration: {
            input_lambda_processor: { # required
              resource_arn: "ResourceARN", # required
              role_arn: "RoleARN", # required
            },
          },
          kinesis_streams_input: {
            resource_arn: "ResourceARN", # required
            role_arn: "RoleARN", # required
          },
          kinesis_firehose_input: {
            resource_arn: "ResourceARN", # required
            role_arn: "RoleARN", # required
          },
          input_parallelism: {
            count: 1,
          },
          input_schema: { # required
            record_format: { # required
              record_format_type: "JSON", # required, accepts JSON, CSV
              mapping_parameters: {
                json_mapping_parameters: {
                  record_row_path: "RecordRowPath", # required
                },
                csv_mapping_parameters: {
                  record_row_delimiter: "RecordRowDelimiter", # required
                  record_column_delimiter: "RecordColumnDelimiter", # required
                },
              },
            },
            record_encoding: "RecordEncoding",
            record_columns: [ # required
              {
                name: "RecordColumnName", # required
                mapping: "RecordColumnMapping",
                sql_type: "RecordColumnSqlType", # required
              },
            ],
          },
        },
      ],
      outputs: [
        {
          name: "InAppStreamName", # required
          kinesis_streams_output: {
            resource_arn: "ResourceARN", # required
            role_arn: "RoleARN", # required
          },
          kinesis_firehose_output: {
            resource_arn: "ResourceARN", # required
            role_arn: "RoleARN", # required
          },
          lambda_output: {
            resource_arn: "ResourceARN", # required
            role_arn: "RoleARN", # required
          },
          destination_schema: { # required
            record_format_type: "JSON", # required, accepts JSON, CSV
          },
        },
      ],
      cloud_watch_logging_options: [
        {
          log_stream_arn: "LogStreamARN", # required
          role_arn: "RoleARN", # required
        },
      ],
      application_code: "ApplicationCode",
      tags: [
        {
          key: "TagKey", # required
          value: "TagValue",
        },
      ],
    }

@!attribute [rw] application_name

Name of your Amazon Kinesis Analytics application (for example,
`sample-app`).
@return [String]

@!attribute [rw] application_description

Summary description of the application.
@return [String]

@!attribute [rw] inputs

Use this parameter to configure the application input.

You can configure your application to receive input from a single
streaming source. In this configuration, you map this streaming
source to an in-application stream that is created. Your application
code can then query the in-application stream like a table (you can
think of it as a constantly updating table).

For the streaming source, you provide its Amazon Resource Name (ARN)
and format of data on the stream (for example, JSON, CSV, etc.). You
also must provide an IAM role that Amazon Kinesis Analytics can
assume to read this stream on your behalf.

To create the in-application stream, you need to specify a schema to
transform your data into a schematized version used in SQL. In the
schema, you provide the necessary mapping of the data elements in
the streaming source to record columns in the in-app stream.
@return [Array<Types::Input>]

@!attribute [rw] outputs

You can configure application output to write data from any of the
in-application streams to up to three destinations.

These destinations can be Amazon Kinesis streams, Amazon Kinesis
Firehose delivery streams, AWS Lambda destinations, or any
combination of the three.

In the configuration, you specify the in-application stream name,
the destination stream or Lambda function Amazon Resource Name
(ARN), and the format to use when writing data. You must also
provide an IAM role that Amazon Kinesis Analytics can assume to
write to the destination stream or Lambda function on your behalf.

In the output configuration, you also provide the output stream or
Lambda function ARN. For stream destinations, you provide the format
of data in the stream (for example, JSON, CSV). You also must
provide an IAM role that Amazon Kinesis Analytics can assume to
write to the stream or Lambda function on your behalf.
@return [Array<Types::Output>]

@!attribute [rw] cloud_watch_logging_options

Use this parameter to configure a CloudWatch log stream to monitor
application configuration errors. For more information, see [Working
with Amazon CloudWatch Logs][1].

[1]: https://docs.aws.amazon.com/kinesisanalytics/latest/dev/cloudwatch-logs.html
@return [Array<Types::CloudWatchLoggingOption>]

@!attribute [rw] application_code

One or more SQL statements that read input data, transform it, and
generate output. For example, you can write a SQL statement that
reads data from one in-application stream, generates a running
average of the number of advertisement clicks by vendor, and insert
resulting rows in another in-application stream using pumps. For
more information about the typical pattern, see [Application
Code][1].

You can provide such series of SQL statements, where output of one
statement can be used as the input for the next statement. You store
intermediate results by creating in-application streams and pumps.

Note that the application code must create the streams with names
specified in the `Outputs`. For example, if your `Outputs` defines
output streams named `ExampleOutputStream1` and
`ExampleOutputStream2`, then your application code must create these
streams.

[1]: https://docs.aws.amazon.com/kinesisanalytics/latest/dev/how-it-works-app-code.html
@return [String]

@!attribute [rw] tags

A list of one or more tags to assign to the application. A tag is a
key-value pair that identifies an application. Note that the maximum
number of application tags includes system tags. The maximum number
of user-defined application tags is 50. For more information, see
[Using Tagging][1].

[1]: https://docs.aws.amazon.com/kinesisanalytics/latest/dev/how-tagging.html
@return [Array<Types::Tag>]

@see docs.aws.amazon.com/goto/WebAPI/kinesisanalytics-2015-08-14/CreateApplicationRequest AWS API Documentation

Constants

SENSITIVE