| 1 | package Paws::Firehose; | ||
| 2 | use Moose; | ||
| 3 | sub service { 'firehose' } | ||
| 4 | sub signing_name { 'firehose' } | ||
| 5 | sub version { '2015-08-04' } | ||
| 6 | sub target_prefix { 'Firehose_20150804' } | ||
| 7 | sub json_version { "1.1" } | ||
| 8 | has max_attempts => (is => 'ro', isa => 'Int', default => 5); | ||
| 9 | has retry => (is => 'ro', isa => 'HashRef', default => sub { | ||
| 10 | { base => 'rand', type => 'exponential', growth_factor => 2 } | ||
| 11 | }); | ||
| 12 | has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [ | ||
| 13 | ] }); | ||
| 14 | |||
| 15 | with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller'; | ||
| 16 | |||
| 17 | |||
| 18 | sub CreateDeliveryStream { | ||
| 19 | my $self = shift; | ||
| 20 | my $call_object = $self->new_with_coercions('Paws::Firehose::CreateDeliveryStream', @_); | ||
| 21 | return $self->caller->do_call($self, $call_object); | ||
| 22 | } | ||
| 23 | sub DeleteDeliveryStream { | ||
| 24 | my $self = shift; | ||
| 25 | my $call_object = $self->new_with_coercions('Paws::Firehose::DeleteDeliveryStream', @_); | ||
| 26 | return $self->caller->do_call($self, $call_object); | ||
| 27 | } | ||
| 28 | sub DescribeDeliveryStream { | ||
| 29 | my $self = shift; | ||
| 30 | my $call_object = $self->new_with_coercions('Paws::Firehose::DescribeDeliveryStream', @_); | ||
| 31 | return $self->caller->do_call($self, $call_object); | ||
| 32 | } | ||
| 33 | sub ListDeliveryStreams { | ||
| 34 | my $self = shift; | ||
| 35 | my $call_object = $self->new_with_coercions('Paws::Firehose::ListDeliveryStreams', @_); | ||
| 36 | return $self->caller->do_call($self, $call_object); | ||
| 37 | } | ||
| 38 | sub ListTagsForDeliveryStream { | ||
| 39 | my $self = shift; | ||
| 40 | my $call_object = $self->new_with_coercions('Paws::Firehose::ListTagsForDeliveryStream', @_); | ||
| 41 | return $self->caller->do_call($self, $call_object); | ||
| 42 | } | ||
| 43 | sub PutRecord { | ||
| 44 | my $self = shift; | ||
| 45 | my $call_object = $self->new_with_coercions('Paws::Firehose::PutRecord', @_); | ||
| 46 | return $self->caller->do_call($self, $call_object); | ||
| 47 | } | ||
| 48 | sub PutRecordBatch { | ||
| 49 | my $self = shift; | ||
| 50 | my $call_object = $self->new_with_coercions('Paws::Firehose::PutRecordBatch', @_); | ||
| 51 | return $self->caller->do_call($self, $call_object); | ||
| 52 | } | ||
| 53 | sub StartDeliveryStreamEncryption { | ||
| 54 | my $self = shift; | ||
| 55 | my $call_object = $self->new_with_coercions('Paws::Firehose::StartDeliveryStreamEncryption', @_); | ||
| 56 | return $self->caller->do_call($self, $call_object); | ||
| 57 | } | ||
| 58 | sub StopDeliveryStreamEncryption { | ||
| 59 | my $self = shift; | ||
| 60 | my $call_object = $self->new_with_coercions('Paws::Firehose::StopDeliveryStreamEncryption', @_); | ||
| 61 | return $self->caller->do_call($self, $call_object); | ||
| 62 | } | ||
| 63 | sub TagDeliveryStream { | ||
| 64 | my $self = shift; | ||
| 65 | my $call_object = $self->new_with_coercions('Paws::Firehose::TagDeliveryStream', @_); | ||
| 66 | return $self->caller->do_call($self, $call_object); | ||
| 67 | } | ||
| 68 | sub UntagDeliveryStream { | ||
| 69 | my $self = shift; | ||
| 70 | my $call_object = $self->new_with_coercions('Paws::Firehose::UntagDeliveryStream', @_); | ||
| 71 | return $self->caller->do_call($self, $call_object); | ||
| 72 | } | ||
| 73 | sub UpdateDestination { | ||
| 74 | my $self = shift; | ||
| 75 | my $call_object = $self->new_with_coercions('Paws::Firehose::UpdateDestination', @_); | ||
| 76 | return $self->caller->do_call($self, $call_object); | ||
| 77 | } | ||
| 78 | |||
| 79 | |||
| 80 | |||
| 81 | sub operations { qw/CreateDeliveryStream DeleteDeliveryStream DescribeDeliveryStream ListDeliveryStreams ListTagsForDeliveryStream PutRecord PutRecordBatch StartDeliveryStreamEncryption StopDeliveryStreamEncryption TagDeliveryStream UntagDeliveryStream UpdateDestination / } | ||
| 82 | |||
| 83 | 1; | ||
| 84 | |||
| 85 | ### main pod documentation begin ### | ||
| 86 | |||
| 87 | =head1 NAME | ||
| 88 | |||
| 89 | Paws::Firehose - Perl Interface to AWS Amazon Kinesis Firehose | ||
| 90 | |||
| 91 | =head1 SYNOPSIS | ||
| 92 | |||
| 93 | use Paws; | ||
| 94 | |||
| 95 | my $obj = Paws->service('Firehose'); | ||
| 96 | my $res = $obj->Method( | ||
| 97 | Arg1 => $val1, | ||
| 98 | Arg2 => [ 'V1', 'V2' ], | ||
| 99 | # if Arg3 is an object, the HashRef will be used as arguments to the constructor | ||
| 100 | # of the arguments type | ||
| 101 | Arg3 => { Att1 => 'Val1' }, | ||
| 102 | # if Arg4 is an array of objects, the HashRefs will be passed as arguments to | ||
| 103 | # the constructor of the arguments type | ||
| 104 | Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ], | ||
| 105 | ); | ||
| 106 | |||
| 107 | =head1 DESCRIPTION | ||
| 108 | |||
| 109 | Amazon Kinesis Data Firehose API Reference | ||
| 110 | |||
| 111 | Amazon Kinesis Data Firehose is a fully managed service that delivers | ||
| 112 | real-time streaming data to destinations such as Amazon Simple Storage | ||
| 113 | Service (Amazon S3), Amazon Elasticsearch Service (Amazon ES), Amazon | ||
| 114 | Redshift, and Splunk. | ||
| 115 | |||
| 116 | For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/firehose-2015-08-04> | ||
| 117 | |||
| 118 | |||
| 119 | =head1 METHODS | ||
| 120 | |||
| 121 | =head2 CreateDeliveryStream | ||
| 122 | |||
| 123 | =over | ||
| 124 | |||
| 125 | =item DeliveryStreamName => Str | ||
| 126 | |||
| 127 | =item [DeliveryStreamEncryptionConfigurationInput => L<Paws::Firehose::DeliveryStreamEncryptionConfigurationInput>] | ||
| 128 | |||
| 129 | =item [DeliveryStreamType => Str] | ||
| 130 | |||
| 131 | =item [ElasticsearchDestinationConfiguration => L<Paws::Firehose::ElasticsearchDestinationConfiguration>] | ||
| 132 | |||
| 133 | =item [ExtendedS3DestinationConfiguration => L<Paws::Firehose::ExtendedS3DestinationConfiguration>] | ||
| 134 | |||
| 135 | =item [HttpEndpointDestinationConfiguration => L<Paws::Firehose::HttpEndpointDestinationConfiguration>] | ||
| 136 | |||
| 137 | =item [KinesisStreamSourceConfiguration => L<Paws::Firehose::KinesisStreamSourceConfiguration>] | ||
| 138 | |||
| 139 | =item [RedshiftDestinationConfiguration => L<Paws::Firehose::RedshiftDestinationConfiguration>] | ||
| 140 | |||
| 141 | =item [S3DestinationConfiguration => L<Paws::Firehose::S3DestinationConfiguration>] | ||
| 142 | |||
| 143 | =item [SplunkDestinationConfiguration => L<Paws::Firehose::SplunkDestinationConfiguration>] | ||
| 144 | |||
| 145 | =item [Tags => ArrayRef[L<Paws::Firehose::Tag>]] | ||
| 146 | |||
| 147 | |||
| 148 | =back | ||
| 149 | |||
| 150 | Each argument is described in detail in: L<Paws::Firehose::CreateDeliveryStream> | ||
| 151 | |||
| 152 | Returns: a L<Paws::Firehose::CreateDeliveryStreamOutput> instance | ||
| 153 | |||
| 154 | Creates a Kinesis Data Firehose delivery stream. | ||
| 155 | |||
| 156 | By default, you can create up to 50 delivery streams per AWS Region. | ||
| 157 | |||
| 158 | This is an asynchronous operation that immediately returns. The initial | ||
| 159 | status of the delivery stream is C<CREATING>. After the delivery stream | ||
| 160 | is created, its status is C<ACTIVE> and it now accepts data. If the | ||
| 161 | delivery stream creation fails, the status transitions to | ||
| 162 | C<CREATING_FAILED>. Attempts to send data to a delivery stream that is | ||
| 163 | not in the C<ACTIVE> state cause an exception. To check the state of a | ||
| 164 | delivery stream, use DescribeDeliveryStream. | ||
| 165 | |||
| 166 | If the status of a delivery stream is C<CREATING_FAILED>, this status | ||
| 167 | doesn't change, and you can't invoke C<CreateDeliveryStream> again on | ||
| 168 | it. However, you can invoke the DeleteDeliveryStream operation to | ||
| 169 | delete it. | ||
| 170 | |||
| 171 | A Kinesis Data Firehose delivery stream can be configured to receive | ||
| 172 | records directly from providers using PutRecord or PutRecordBatch, or | ||
| 173 | it can be configured to use an existing Kinesis stream as its source. | ||
| 174 | To specify a Kinesis data stream as input, set the | ||
| 175 | C<DeliveryStreamType> parameter to C<KinesisStreamAsSource>, and | ||
| 176 | provide the Kinesis stream Amazon Resource Name (ARN) and role ARN in | ||
| 177 | the C<KinesisStreamSourceConfiguration> parameter. | ||
| 178 | |||
| 179 | To create a delivery stream with server-side encryption (SSE) enabled, | ||
| 180 | include DeliveryStreamEncryptionConfigurationInput in your request. | ||
| 181 | This is optional. You can also invoke StartDeliveryStreamEncryption to | ||
| 182 | turn on SSE for an existing delivery stream that doesn't have SSE | ||
| 183 | enabled. | ||
| 184 | |||
| 185 | A delivery stream is configured with a single destination: Amazon S3, | ||
| 186 | Amazon ES, Amazon Redshift, or Splunk. You must specify only one of the | ||
| 187 | following destination configuration parameters: | ||
| 188 | C<ExtendedS3DestinationConfiguration>, C<S3DestinationConfiguration>, | ||
| 189 | C<ElasticsearchDestinationConfiguration>, | ||
| 190 | C<RedshiftDestinationConfiguration>, or | ||
| 191 | C<SplunkDestinationConfiguration>. | ||
| 192 | |||
| 193 | When you specify C<S3DestinationConfiguration>, you can also provide | ||
| 194 | the following optional values: BufferingHints, | ||
| 195 | C<EncryptionConfiguration>, and C<CompressionFormat>. By default, if no | ||
| 196 | C<BufferingHints> value is provided, Kinesis Data Firehose buffers data | ||
| 197 | up to 5 MB or for 5 minutes, whichever condition is satisfied first. | ||
| 198 | C<BufferingHints> is a hint, so there are some cases where the service | ||
| 199 | cannot adhere to these conditions strictly. For example, record | ||
| 200 | boundaries might be such that the size is a little over or under the | ||
| 201 | configured buffering size. By default, no encryption is performed. We | ||
| 202 | strongly recommend that you enable encryption to ensure secure data | ||
| 203 | storage in Amazon S3. | ||
| 204 | |||
| 205 | A few notes about Amazon Redshift as a destination: | ||
| 206 | |||
| 207 | =over | ||
| 208 | |||
| 209 | =item * | ||
| 210 | |||
| 211 | An Amazon Redshift destination requires an S3 bucket as intermediate | ||
| 212 | location. Kinesis Data Firehose first delivers data to Amazon S3 and | ||
| 213 | then uses C<COPY> syntax to load data into an Amazon Redshift table. | ||
| 214 | This is specified in the | ||
| 215 | C<RedshiftDestinationConfiguration.S3Configuration> parameter. | ||
| 216 | |||
| 217 | =item * | ||
| 218 | |||
| 219 | The compression formats C<SNAPPY> or C<ZIP> cannot be specified in | ||
| 220 | C<RedshiftDestinationConfiguration.S3Configuration> because the Amazon | ||
| 221 | Redshift C<COPY> operation that reads from the S3 bucket doesn't | ||
| 222 | support these compression formats. | ||
| 223 | |||
| 224 | =item * | ||
| 225 | |||
| 226 | We strongly recommend that you use the user name and password you | ||
| 227 | provide exclusively with Kinesis Data Firehose, and that the | ||
| 228 | permissions for the account are restricted for Amazon Redshift | ||
| 229 | C<INSERT> permissions. | ||
| 230 | |||
| 231 | =back | ||
| 232 | |||
| 233 | Kinesis Data Firehose assumes the IAM role that is configured as part | ||
| 234 | of the destination. The role should allow the Kinesis Data Firehose | ||
| 235 | principal to assume the role, and the role should have permissions that | ||
| 236 | allow the service to deliver the data. For more information, see Grant | ||
| 237 | Kinesis Data Firehose Access to an Amazon S3 Destination | ||
| 238 | (https://docs.aws.amazon.com/firehose/latest/dev/controlling-access.html#using-iam-s3) | ||
| 239 | in the I<Amazon Kinesis Data Firehose Developer Guide>. | ||
| 240 | |||
| 241 | |||
| 242 | =head2 DeleteDeliveryStream | ||
| 243 | |||
| 244 | =over | ||
| 245 | |||
| 246 | =item DeliveryStreamName => Str | ||
| 247 | |||
| 248 | =item [AllowForceDelete => Bool] | ||
| 249 | |||
| 250 | |||
| 251 | =back | ||
| 252 | |||
| 253 | Each argument is described in detail in: L<Paws::Firehose::DeleteDeliveryStream> | ||
| 254 | |||
| 255 | Returns: a L<Paws::Firehose::DeleteDeliveryStreamOutput> instance | ||
| 256 | |||
| 257 | Deletes a delivery stream and its data. | ||
| 258 | |||
| 259 | To check the state of a delivery stream, use DescribeDeliveryStream. | ||
| 260 | You can delete a delivery stream only if it is in one of the following | ||
| 261 | states: C<ACTIVE>, C<DELETING>, C<CREATING_FAILED>, or | ||
| 262 | C<DELETING_FAILED>. You can't delete a delivery stream that is in the | ||
| 263 | C<CREATING> state. While the deletion request is in process, the | ||
| 264 | delivery stream is in the C<DELETING> state. | ||
| 265 | |||
| 266 | While the delivery stream is in the C<DELETING> state, the service | ||
| 267 | might continue to accept records, but it doesn't make any guarantees | ||
| 268 | with respect to delivering the data. Therefore, as a best practice, | ||
| 269 | first stop any applications that are sending records before you delete | ||
| 270 | a delivery stream. | ||
| 271 | |||
| 272 | |||
| 273 | =head2 DescribeDeliveryStream | ||
| 274 | |||
| 275 | =over | ||
| 276 | |||
| 277 | =item DeliveryStreamName => Str | ||
| 278 | |||
| 279 | =item [ExclusiveStartDestinationId => Str] | ||
| 280 | |||
| 281 | =item [Limit => Int] | ||
| 282 | |||
| 283 | |||
| 284 | =back | ||
| 285 | |||
| 286 | Each argument is described in detail in: L<Paws::Firehose::DescribeDeliveryStream> | ||
| 287 | |||
| 288 | Returns: a L<Paws::Firehose::DescribeDeliveryStreamOutput> instance | ||
| 289 | |||
| 290 | Describes the specified delivery stream and its status. For example, | ||
| 291 | after your delivery stream is created, call C<DescribeDeliveryStream> | ||
| 292 | to see whether the delivery stream is C<ACTIVE> and therefore ready for | ||
| 293 | data to be sent to it. | ||
| 294 | |||
| 295 | If the status of a delivery stream is C<CREATING_FAILED>, this status | ||
| 296 | doesn't change, and you can't invoke CreateDeliveryStream again on it. | ||
| 297 | However, you can invoke the DeleteDeliveryStream operation to delete | ||
| 298 | it. If the status is C<DELETING_FAILED>, you can force deletion by | ||
| 299 | invoking DeleteDeliveryStream again but with | ||
| 300 | DeleteDeliveryStreamInput$AllowForceDelete set to true. | ||
| 301 | |||
| 302 | |||
| 303 | =head2 ListDeliveryStreams | ||
| 304 | |||
| 305 | =over | ||
| 306 | |||
| 307 | =item [DeliveryStreamType => Str] | ||
| 308 | |||
| 309 | =item [ExclusiveStartDeliveryStreamName => Str] | ||
| 310 | |||
| 311 | =item [Limit => Int] | ||
| 312 | |||
| 313 | |||
| 314 | =back | ||
| 315 | |||
| 316 | Each argument is described in detail in: L<Paws::Firehose::ListDeliveryStreams> | ||
| 317 | |||
| 318 | Returns: a L<Paws::Firehose::ListDeliveryStreamsOutput> instance | ||
| 319 | |||
| 320 | Lists your delivery streams in alphabetical order of their names. | ||
| 321 | |||
| 322 | The number of delivery streams might be too large to return using a | ||
| 323 | single call to C<ListDeliveryStreams>. You can limit the number of | ||
| 324 | delivery streams returned, using the C<Limit> parameter. To determine | ||
| 325 | whether there are more delivery streams to list, check the value of | ||
| 326 | C<HasMoreDeliveryStreams> in the output. If there are more delivery | ||
| 327 | streams to list, you can request them by calling this operation again | ||
| 328 | and setting the C<ExclusiveStartDeliveryStreamName> parameter to the | ||
| 329 | name of the last delivery stream returned in the last call. | ||
| 330 | |||
| 331 | |||
| 332 | =head2 ListTagsForDeliveryStream | ||
| 333 | |||
| 334 | =over | ||
| 335 | |||
| 336 | =item DeliveryStreamName => Str | ||
| 337 | |||
| 338 | =item [ExclusiveStartTagKey => Str] | ||
| 339 | |||
| 340 | =item [Limit => Int] | ||
| 341 | |||
| 342 | |||
| 343 | =back | ||
| 344 | |||
| 345 | Each argument is described in detail in: L<Paws::Firehose::ListTagsForDeliveryStream> | ||
| 346 | |||
| 347 | Returns: a L<Paws::Firehose::ListTagsForDeliveryStreamOutput> instance | ||
| 348 | |||
| 349 | Lists the tags for the specified delivery stream. This operation has a | ||
| 350 | limit of five transactions per second per account. | ||
| 351 | |||
| 352 | |||
| 353 | =head2 PutRecord | ||
| 354 | |||
| 355 | =over | ||
| 356 | |||
| 357 | =item DeliveryStreamName => Str | ||
| 358 | |||
| 359 | =item Record => L<Paws::Firehose::Record> | ||
| 360 | |||
| 361 | |||
| 362 | =back | ||
| 363 | |||
| 364 | Each argument is described in detail in: L<Paws::Firehose::PutRecord> | ||
| 365 | |||
| 366 | Returns: a L<Paws::Firehose::PutRecordOutput> instance | ||
| 367 | |||
| 368 | Writes a single data record into an Amazon Kinesis Data Firehose | ||
| 369 | delivery stream. To write multiple data records into a delivery stream, | ||
| 370 | use PutRecordBatch. Applications using these operations are referred to | ||
| 371 | as producers. | ||
| 372 | |||
| 373 | By default, each delivery stream can take in up to 2,000 transactions | ||
| 374 | per second, 5,000 records per second, or 5 MB per second. If you use | ||
| 375 | PutRecord and PutRecordBatch, the limits are an aggregate across these | ||
| 376 | two operations for each delivery stream. For more information about | ||
| 377 | limits and how to request an increase, see Amazon Kinesis Data Firehose | ||
| 378 | Limits (https://docs.aws.amazon.com/firehose/latest/dev/limits.html). | ||
| 379 | |||
| 380 | You must specify the name of the delivery stream and the data record | ||
| 381 | when using PutRecord. The data record consists of a data blob that can | ||
| 382 | be up to 1,000 KB in size, and any kind of data. For example, it can be | ||
| 383 | a segment from a log file, geographic location data, website | ||
| 384 | clickstream data, and so on. | ||
| 385 | |||
| 386 | Kinesis Data Firehose buffers records before delivering them to the | ||
| 387 | destination. To disambiguate the data blobs at the destination, a | ||
| 388 | common solution is to use delimiters in the data, such as a newline | ||
| 389 | (C<\n>) or some other character unique within the data. This allows the | ||
| 390 | consumer application to parse individual data items when reading the | ||
| 391 | data from the destination. | ||
| 392 | |||
| 393 | The C<PutRecord> operation returns a C<RecordId>, which is a unique | ||
| 394 | string assigned to each record. Producer applications can use this ID | ||
| 395 | for purposes such as auditability and investigation. | ||
| 396 | |||
| 397 | If the C<PutRecord> operation throws a C<ServiceUnavailableException>, | ||
| 398 | back off and retry. If the exception persists, it is possible that the | ||
| 399 | throughput limits have been exceeded for the delivery stream. | ||
| 400 | |||
| 401 | Data records sent to Kinesis Data Firehose are stored for 24 hours from | ||
| 402 | the time they are added to a delivery stream as it tries to send the | ||
| 403 | records to the destination. If the destination is unreachable for more | ||
| 404 | than 24 hours, the data is no longer available. | ||
| 405 | |||
| 406 | Don't concatenate two or more base64 strings to form the data fields of | ||
| 407 | your records. Instead, concatenate the raw data, then perform base64 | ||
| 408 | encoding. | ||
| 409 | |||
| 410 | |||
| 411 | =head2 PutRecordBatch | ||
| 412 | |||
| 413 | =over | ||
| 414 | |||
| 415 | =item DeliveryStreamName => Str | ||
| 416 | |||
| 417 | =item Records => ArrayRef[L<Paws::Firehose::Record>] | ||
| 418 | |||
| 419 | |||
| 420 | =back | ||
| 421 | |||
| 422 | Each argument is described in detail in: L<Paws::Firehose::PutRecordBatch> | ||
| 423 | |||
| 424 | Returns: a L<Paws::Firehose::PutRecordBatchOutput> instance | ||
| 425 | |||
| 426 | Writes multiple data records into a delivery stream in a single call, | ||
| 427 | which can achieve higher throughput per producer than when writing | ||
| 428 | single records. To write single data records into a delivery stream, | ||
| 429 | use PutRecord. Applications using these operations are referred to as | ||
| 430 | producers. | ||
| 431 | |||
| 432 | For information about service quota, see Amazon Kinesis Data Firehose | ||
| 433 | Quota (https://docs.aws.amazon.com/firehose/latest/dev/limits.html). | ||
| 434 | |||
| 435 | Each PutRecordBatch request supports up to 500 records. Each record in | ||
| 436 | the request can be as large as 1,000 KB (before 64-bit encoding), up to | ||
| 437 | a limit of 4 MB for the entire request. These limits cannot be changed. | ||
| 438 | |||
| 439 | You must specify the name of the delivery stream and the data record | ||
| 440 | when using PutRecord. The data record consists of a data blob that can | ||
| 441 | be up to 1,000 KB in size, and any kind of data. For example, it could | ||
| 442 | be a segment from a log file, geographic location data, website | ||
| 443 | clickstream data, and so on. | ||
| 444 | |||
| 445 | Kinesis Data Firehose buffers records before delivering them to the | ||
| 446 | destination. To disambiguate the data blobs at the destination, a | ||
| 447 | common solution is to use delimiters in the data, such as a newline | ||
| 448 | (C<\n>) or some other character unique within the data. This allows the | ||
| 449 | consumer application to parse individual data items when reading the | ||
| 450 | data from the destination. | ||
| 451 | |||
| 452 | The PutRecordBatch response includes a count of failed records, | ||
| 453 | C<FailedPutCount>, and an array of responses, C<RequestResponses>. Even | ||
| 454 | if the PutRecordBatch call succeeds, the value of C<FailedPutCount> may | ||
| 455 | be greater than 0, indicating that there are records for which the | ||
| 456 | operation didn't succeed. Each entry in the C<RequestResponses> array | ||
| 457 | provides additional information about the processed record. It directly | ||
| 458 | correlates with a record in the request array using the same ordering, | ||
| 459 | from the top to the bottom. The response array always includes the same | ||
| 460 | number of records as the request array. C<RequestResponses> includes | ||
| 461 | both successfully and unsuccessfully processed records. Kinesis Data | ||
| 462 | Firehose tries to process all records in each PutRecordBatch request. A | ||
| 463 | single record failure does not stop the processing of subsequent | ||
| 464 | records. | ||
| 465 | |||
| 466 | A successfully processed record includes a C<RecordId> value, which is | ||
| 467 | unique for the record. An unsuccessfully processed record includes | ||
| 468 | C<ErrorCode> and C<ErrorMessage> values. C<ErrorCode> reflects the type | ||
| 469 | of error, and is one of the following values: | ||
| 470 | C<ServiceUnavailableException> or C<InternalFailure>. C<ErrorMessage> | ||
| 471 | provides more detailed information about the error. | ||
| 472 | |||
| 473 | If there is an internal server error or a timeout, the write might have | ||
| 474 | completed or it might have failed. If C<FailedPutCount> is greater than | ||
| 475 | 0, retry the request, resending only those records that might have | ||
| 476 | failed processing. This minimizes the possible duplicate records and | ||
| 477 | also reduces the total bytes sent (and corresponding charges). We | ||
| 478 | recommend that you handle any duplicates at the destination. | ||
| 479 | |||
| 480 | If PutRecordBatch throws C<ServiceUnavailableException>, back off and | ||
| 481 | retry. If the exception persists, it is possible that the throughput | ||
| 482 | limits have been exceeded for the delivery stream. | ||
| 483 | |||
| 484 | Data records sent to Kinesis Data Firehose are stored for 24 hours from | ||
| 485 | the time they are added to a delivery stream as it attempts to send the | ||
| 486 | records to the destination. If the destination is unreachable for more | ||
| 487 | than 24 hours, the data is no longer available. | ||
| 488 | |||
| 489 | Don't concatenate two or more base64 strings to form the data fields of | ||
| 490 | your records. Instead, concatenate the raw data, then perform base64 | ||
| 491 | encoding. | ||
| 492 | |||
| 493 | |||
| 494 | =head2 StartDeliveryStreamEncryption | ||
| 495 | |||
| 496 | =over | ||
| 497 | |||
| 498 | =item DeliveryStreamName => Str | ||
| 499 | |||
| 500 | =item [DeliveryStreamEncryptionConfigurationInput => L<Paws::Firehose::DeliveryStreamEncryptionConfigurationInput>] | ||
| 501 | |||
| 502 | |||
| 503 | =back | ||
| 504 | |||
| 505 | Each argument is described in detail in: L<Paws::Firehose::StartDeliveryStreamEncryption> | ||
| 506 | |||
| 507 | Returns: a L<Paws::Firehose::StartDeliveryStreamEncryptionOutput> instance | ||
| 508 | |||
| 509 | Enables server-side encryption (SSE) for the delivery stream. | ||
| 510 | |||
| 511 | This operation is asynchronous. It returns immediately. When you invoke | ||
| 512 | it, Kinesis Data Firehose first sets the encryption status of the | ||
| 513 | stream to C<ENABLING>, and then to C<ENABLED>. The encryption status of | ||
| 514 | a delivery stream is the C<Status> property in | ||
| 515 | DeliveryStreamEncryptionConfiguration. If the operation fails, the | ||
| 516 | encryption status changes to C<ENABLING_FAILED>. You can continue to | ||
| 517 | read and write data to your delivery stream while the encryption status | ||
| 518 | is C<ENABLING>, but the data is not encrypted. It can take up to 5 | ||
| 519 | seconds after the encryption status changes to C<ENABLED> before all | ||
| 520 | records written to the delivery stream are encrypted. To find out | ||
| 521 | whether a record or a batch of records was encrypted, check the | ||
| 522 | response elements PutRecordOutput$Encrypted and | ||
| 523 | PutRecordBatchOutput$Encrypted, respectively. | ||
| 524 | |||
| 525 | To check the encryption status of a delivery stream, use | ||
| 526 | DescribeDeliveryStream. | ||
| 527 | |||
| 528 | Even if encryption is currently enabled for a delivery stream, you can | ||
| 529 | still invoke this operation on it to change the ARN of the CMK or both | ||
| 530 | its type and ARN. If you invoke this method to change the CMK, and the | ||
| 531 | old CMK is of type C<CUSTOMER_MANAGED_CMK>, Kinesis Data Firehose | ||
| 532 | schedules the grant it had on the old CMK for retirement. If the new | ||
| 533 | CMK is of type C<CUSTOMER_MANAGED_CMK>, Kinesis Data Firehose creates a | ||
| 534 | grant that enables it to use the new CMK to encrypt and decrypt data | ||
| 535 | and to manage the grant. | ||
| 536 | |||
| 537 | If a delivery stream already has encryption enabled and then you invoke | ||
| 538 | this operation to change the ARN of the CMK or both its type and ARN | ||
| 539 | and you get C<ENABLING_FAILED>, this only means that the attempt to | ||
| 540 | change the CMK failed. In this case, encryption remains enabled with | ||
| 541 | the old CMK. | ||
| 542 | |||
| 543 | If the encryption status of your delivery stream is C<ENABLING_FAILED>, | ||
| 544 | you can invoke this operation again with a valid CMK. The CMK must be | ||
| 545 | enabled and the key policy mustn't explicitly deny the permission for | ||
| 546 | Kinesis Data Firehose to invoke KMS encrypt and decrypt operations. | ||
| 547 | |||
| 548 | You can enable SSE for a delivery stream only if it's a delivery stream | ||
| 549 | that uses C<DirectPut> as its source. | ||
| 550 | |||
| 551 | The C<StartDeliveryStreamEncryption> and | ||
| 552 | C<StopDeliveryStreamEncryption> operations have a combined limit of 25 | ||
| 553 | calls per delivery stream per 24 hours. For example, you reach the | ||
| 554 | limit if you call C<StartDeliveryStreamEncryption> 13 times and | ||
| 555 | C<StopDeliveryStreamEncryption> 12 times for the same delivery stream | ||
| 556 | in a 24-hour period. | ||
| 557 | |||
| 558 | |||
| 559 | =head2 StopDeliveryStreamEncryption | ||
| 560 | |||
| 561 | =over | ||
| 562 | |||
| 563 | =item DeliveryStreamName => Str | ||
| 564 | |||
| 565 | |||
| 566 | =back | ||
| 567 | |||
| 568 | Each argument is described in detail in: L<Paws::Firehose::StopDeliveryStreamEncryption> | ||
| 569 | |||
| 570 | Returns: a L<Paws::Firehose::StopDeliveryStreamEncryptionOutput> instance | ||
| 571 | |||
| 572 | Disables server-side encryption (SSE) for the delivery stream. | ||
| 573 | |||
| 574 | This operation is asynchronous. It returns immediately. When you invoke | ||
| 575 | it, Kinesis Data Firehose first sets the encryption status of the | ||
| 576 | stream to C<DISABLING>, and then to C<DISABLED>. You can continue to | ||
| 577 | read and write data to your stream while its status is C<DISABLING>. It | ||
| 578 | can take up to 5 seconds after the encryption status changes to | ||
| 579 | C<DISABLED> before all records written to the delivery stream are no | ||
| 580 | longer subject to encryption. To find out whether a record or a batch | ||
| 581 | of records was encrypted, check the response elements | ||
| 582 | PutRecordOutput$Encrypted and PutRecordBatchOutput$Encrypted, | ||
| 583 | respectively. | ||
| 584 | |||
| 585 | To check the encryption state of a delivery stream, use | ||
| 586 | DescribeDeliveryStream. | ||
| 587 | |||
| 588 | If SSE is enabled using a customer managed CMK and then you invoke | ||
| 589 | C<StopDeliveryStreamEncryption>, Kinesis Data Firehose schedules the | ||
| 590 | related KMS grant for retirement and then retires it after it ensures | ||
| 591 | that it is finished delivering records to the destination. | ||
| 592 | |||
| 593 | The C<StartDeliveryStreamEncryption> and | ||
| 594 | C<StopDeliveryStreamEncryption> operations have a combined limit of 25 | ||
| 595 | calls per delivery stream per 24 hours. For example, you reach the | ||
| 596 | limit if you call C<StartDeliveryStreamEncryption> 13 times and | ||
| 597 | C<StopDeliveryStreamEncryption> 12 times for the same delivery stream | ||
| 598 | in a 24-hour period. | ||
| 599 | |||
| 600 | |||
| 601 | =head2 TagDeliveryStream | ||
| 602 | |||
| 603 | =over | ||
| 604 | |||
| 605 | =item DeliveryStreamName => Str | ||
| 606 | |||
| 607 | =item Tags => ArrayRef[L<Paws::Firehose::Tag>] | ||
| 608 | |||
| 609 | |||
| 610 | =back | ||
| 611 | |||
| 612 | Each argument is described in detail in: L<Paws::Firehose::TagDeliveryStream> | ||
| 613 | |||
| 614 | Returns: a L<Paws::Firehose::TagDeliveryStreamOutput> instance | ||
| 615 | |||
| 616 | Adds or updates tags for the specified delivery stream. A tag is a | ||
| 617 | key-value pair that you can define and assign to AWS resources. If you | ||
| 618 | specify a tag that already exists, the tag value is replaced with the | ||
| 619 | value that you specify in the request. Tags are metadata. For example, | ||
| 620 | you can add friendly names and descriptions or other types of | ||
| 621 | information that can help you distinguish the delivery stream. For more | ||
| 622 | information about tags, see Using Cost Allocation Tags | ||
| 623 | (https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html) | ||
| 624 | in the I<AWS Billing and Cost Management User Guide>. | ||
| 625 | |||
| 626 | Each delivery stream can have up to 50 tags. | ||
| 627 | |||
| 628 | This operation has a limit of five transactions per second per account. | ||
| 629 | |||
| 630 | |||
| 631 | =head2 UntagDeliveryStream | ||
| 632 | |||
| 633 | =over | ||
| 634 | |||
| 635 | =item DeliveryStreamName => Str | ||
| 636 | |||
| 637 | =item TagKeys => ArrayRef[Str|Undef] | ||
| 638 | |||
| 639 | |||
| 640 | =back | ||
| 641 | |||
| 642 | Each argument is described in detail in: L<Paws::Firehose::UntagDeliveryStream> | ||
| 643 | |||
| 644 | Returns: a L<Paws::Firehose::UntagDeliveryStreamOutput> instance | ||
| 645 | |||
| 646 | Removes tags from the specified delivery stream. Removed tags are | ||
| 647 | deleted, and you can't recover them after this operation successfully | ||
| 648 | completes. | ||
| 649 | |||
| 650 | If you specify a tag that doesn't exist, the operation ignores it. | ||
| 651 | |||
| 652 | This operation has a limit of five transactions per second per account. | ||
| 653 | |||
| 654 | |||
| 655 | =head2 UpdateDestination | ||
| 656 | |||
| 657 | =over | ||
| 658 | |||
| 659 | =item CurrentDeliveryStreamVersionId => Str | ||
| 660 | |||
| 661 | =item DeliveryStreamName => Str | ||
| 662 | |||
| 663 | =item DestinationId => Str | ||
| 664 | |||
| 665 | =item [ElasticsearchDestinationUpdate => L<Paws::Firehose::ElasticsearchDestinationUpdate>] | ||
| 666 | |||
| 667 | =item [ExtendedS3DestinationUpdate => L<Paws::Firehose::ExtendedS3DestinationUpdate>] | ||
| 668 | |||
| 669 | =item [HttpEndpointDestinationUpdate => L<Paws::Firehose::HttpEndpointDestinationUpdate>] | ||
| 670 | |||
| 671 | =item [RedshiftDestinationUpdate => L<Paws::Firehose::RedshiftDestinationUpdate>] | ||
| 672 | |||
| 673 | =item [S3DestinationUpdate => L<Paws::Firehose::S3DestinationUpdate>] | ||
| 674 | |||
| 675 | =item [SplunkDestinationUpdate => L<Paws::Firehose::SplunkDestinationUpdate>] | ||
| 676 | |||
| 677 | |||
| 678 | =back | ||
| 679 | |||
| 680 | Each argument is described in detail in: L<Paws::Firehose::UpdateDestination> | ||
| 681 | |||
| 682 | Returns: a L<Paws::Firehose::UpdateDestinationOutput> instance | ||
| 683 | |||
| 684 | Updates the specified destination of the specified delivery stream. | ||
| 685 | |||
| 686 | Use this operation to change the destination type (for example, to | ||
| 687 | replace the Amazon S3 destination with Amazon Redshift) or change the | ||
| 688 | parameters associated with a destination (for example, to change the | ||
| 689 | bucket name of the Amazon S3 destination). The update might not occur | ||
| 690 | immediately. The target delivery stream remains active while the | ||
| 691 | configurations are updated, so data writes to the delivery stream can | ||
| 692 | continue during this process. The updated configurations are usually | ||
| 693 | effective within a few minutes. | ||
| 694 | |||
| 695 | Switching between Amazon ES and other services is not supported. For an | ||
| 696 | Amazon ES destination, you can only update to another Amazon ES | ||
| 697 | destination. | ||
| 698 | |||
| 699 | If the destination type is the same, Kinesis Data Firehose merges the | ||
| 700 | configuration parameters specified with the destination configuration | ||
| 701 | that already exists on the delivery stream. If any of the parameters | ||
| 702 | are not specified in the call, the existing values are retained. For | ||
| 703 | example, in the Amazon S3 destination, if EncryptionConfiguration is | ||
| 704 | not specified, then the existing C<EncryptionConfiguration> is | ||
| 705 | maintained on the destination. | ||
| 706 | |||
| 707 | If the destination type is not the same, for example, changing the | ||
| 708 | destination from Amazon S3 to Amazon Redshift, Kinesis Data Firehose | ||
| 709 | does not merge any parameters. In this case, all parameters must be | ||
| 710 | specified. | ||
| 711 | |||
| 712 | Kinesis Data Firehose uses C<CurrentDeliveryStreamVersionId> to avoid | ||
| 713 | race conditions and conflicting merges. This is a required field, and | ||
| 714 | the service updates the configuration only if the existing | ||
| 715 | configuration has a version ID that matches. After the update is | ||
| 716 | applied successfully, the version ID is updated, and can be retrieved | ||
| 717 | using DescribeDeliveryStream. Use the new version ID to set | ||
| 718 | C<CurrentDeliveryStreamVersionId> in the next call. | ||
| 719 | |||
| 720 | |||
| 721 | |||
| 722 | |||
| 723 | =head1 PAGINATORS | ||
| 724 | |||
| 725 | Paginator methods are helpers that repetively call methods that return partial results | ||
| 726 | |||
| 727 | |||
| 728 | |||
| 729 | |||
| 730 | =head1 SEE ALSO | ||
| 731 | |||
| 732 | This service class forms part of L<Paws> | ||
| 733 | |||
| 734 | =head1 BUGS and CONTRIBUTIONS | ||
| 735 | |||
| 736 | The source code is located here: L<https://github.com/pplu/aws-sdk-perl> | ||
| 737 | |||
| 738 | Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues> | ||
| 739 | |||
| 740 | =cut | ||
| 741 |