File Coverage

blib/lib/Paws/Config.pm
Criterion Covered Total %
statement 3 3 100.0
branch n/a
condition n/a
subroutine 1 1 100.0
pod n/a
total 4 4 100.0


line stmt bran cond sub pod time code
1             package Paws::Config;
2 1     1   2588 use Moose;
  1         2  
  1         8  
3             sub service { 'config' }
4             sub version { '2014-11-12' }
5             sub target_prefix { 'StarlingDoveService' }
6             sub json_version { "1.1" }
7             has max_attempts => (is => 'ro', isa => 'Int', default => 5);
8             has retry => (is => 'ro', isa => 'HashRef', default => sub {
9             { base => 'rand', type => 'exponential', growth_factor => 2 }
10             });
11             has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
12             ] });
13              
14             with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller', 'Paws::Net::JsonResponse';
15              
16            
17             sub DeleteConfigRule {
18             my $self = shift;
19             my $call_object = $self->new_with_coercions('Paws::Config::DeleteConfigRule', @_);
20             return $self->caller->do_call($self, $call_object);
21             }
22             sub DeleteConfigurationRecorder {
23             my $self = shift;
24             my $call_object = $self->new_with_coercions('Paws::Config::DeleteConfigurationRecorder', @_);
25             return $self->caller->do_call($self, $call_object);
26             }
27             sub DeleteDeliveryChannel {
28             my $self = shift;
29             my $call_object = $self->new_with_coercions('Paws::Config::DeleteDeliveryChannel', @_);
30             return $self->caller->do_call($self, $call_object);
31             }
32             sub DeleteEvaluationResults {
33             my $self = shift;
34             my $call_object = $self->new_with_coercions('Paws::Config::DeleteEvaluationResults', @_);
35             return $self->caller->do_call($self, $call_object);
36             }
37             sub DeliverConfigSnapshot {
38             my $self = shift;
39             my $call_object = $self->new_with_coercions('Paws::Config::DeliverConfigSnapshot', @_);
40             return $self->caller->do_call($self, $call_object);
41             }
42             sub DescribeComplianceByConfigRule {
43             my $self = shift;
44             my $call_object = $self->new_with_coercions('Paws::Config::DescribeComplianceByConfigRule', @_);
45             return $self->caller->do_call($self, $call_object);
46             }
47             sub DescribeComplianceByResource {
48             my $self = shift;
49             my $call_object = $self->new_with_coercions('Paws::Config::DescribeComplianceByResource', @_);
50             return $self->caller->do_call($self, $call_object);
51             }
52             sub DescribeConfigRuleEvaluationStatus {
53             my $self = shift;
54             my $call_object = $self->new_with_coercions('Paws::Config::DescribeConfigRuleEvaluationStatus', @_);
55             return $self->caller->do_call($self, $call_object);
56             }
57             sub DescribeConfigRules {
58             my $self = shift;
59             my $call_object = $self->new_with_coercions('Paws::Config::DescribeConfigRules', @_);
60             return $self->caller->do_call($self, $call_object);
61             }
62             sub DescribeConfigurationRecorders {
63             my $self = shift;
64             my $call_object = $self->new_with_coercions('Paws::Config::DescribeConfigurationRecorders', @_);
65             return $self->caller->do_call($self, $call_object);
66             }
67             sub DescribeConfigurationRecorderStatus {
68             my $self = shift;
69             my $call_object = $self->new_with_coercions('Paws::Config::DescribeConfigurationRecorderStatus', @_);
70             return $self->caller->do_call($self, $call_object);
71             }
72             sub DescribeDeliveryChannels {
73             my $self = shift;
74             my $call_object = $self->new_with_coercions('Paws::Config::DescribeDeliveryChannels', @_);
75             return $self->caller->do_call($self, $call_object);
76             }
77             sub DescribeDeliveryChannelStatus {
78             my $self = shift;
79             my $call_object = $self->new_with_coercions('Paws::Config::DescribeDeliveryChannelStatus', @_);
80             return $self->caller->do_call($self, $call_object);
81             }
82             sub GetComplianceDetailsByConfigRule {
83             my $self = shift;
84             my $call_object = $self->new_with_coercions('Paws::Config::GetComplianceDetailsByConfigRule', @_);
85             return $self->caller->do_call($self, $call_object);
86             }
87             sub GetComplianceDetailsByResource {
88             my $self = shift;
89             my $call_object = $self->new_with_coercions('Paws::Config::GetComplianceDetailsByResource', @_);
90             return $self->caller->do_call($self, $call_object);
91             }
92             sub GetComplianceSummaryByConfigRule {
93             my $self = shift;
94             my $call_object = $self->new_with_coercions('Paws::Config::GetComplianceSummaryByConfigRule', @_);
95             return $self->caller->do_call($self, $call_object);
96             }
97             sub GetComplianceSummaryByResourceType {
98             my $self = shift;
99             my $call_object = $self->new_with_coercions('Paws::Config::GetComplianceSummaryByResourceType', @_);
100             return $self->caller->do_call($self, $call_object);
101             }
102             sub GetDiscoveredResourceCounts {
103             my $self = shift;
104             my $call_object = $self->new_with_coercions('Paws::Config::GetDiscoveredResourceCounts', @_);
105             return $self->caller->do_call($self, $call_object);
106             }
107             sub GetResourceConfigHistory {
108             my $self = shift;
109             my $call_object = $self->new_with_coercions('Paws::Config::GetResourceConfigHistory', @_);
110             return $self->caller->do_call($self, $call_object);
111             }
112             sub ListDiscoveredResources {
113             my $self = shift;
114             my $call_object = $self->new_with_coercions('Paws::Config::ListDiscoveredResources', @_);
115             return $self->caller->do_call($self, $call_object);
116             }
117             sub PutConfigRule {
118             my $self = shift;
119             my $call_object = $self->new_with_coercions('Paws::Config::PutConfigRule', @_);
120             return $self->caller->do_call($self, $call_object);
121             }
122             sub PutConfigurationRecorder {
123             my $self = shift;
124             my $call_object = $self->new_with_coercions('Paws::Config::PutConfigurationRecorder', @_);
125             return $self->caller->do_call($self, $call_object);
126             }
127             sub PutDeliveryChannel {
128             my $self = shift;
129             my $call_object = $self->new_with_coercions('Paws::Config::PutDeliveryChannel', @_);
130             return $self->caller->do_call($self, $call_object);
131             }
132             sub PutEvaluations {
133             my $self = shift;
134             my $call_object = $self->new_with_coercions('Paws::Config::PutEvaluations', @_);
135             return $self->caller->do_call($self, $call_object);
136             }
137             sub StartConfigRulesEvaluation {
138             my $self = shift;
139             my $call_object = $self->new_with_coercions('Paws::Config::StartConfigRulesEvaluation', @_);
140             return $self->caller->do_call($self, $call_object);
141             }
142             sub StartConfigurationRecorder {
143             my $self = shift;
144             my $call_object = $self->new_with_coercions('Paws::Config::StartConfigurationRecorder', @_);
145             return $self->caller->do_call($self, $call_object);
146             }
147             sub StopConfigurationRecorder {
148             my $self = shift;
149             my $call_object = $self->new_with_coercions('Paws::Config::StopConfigurationRecorder', @_);
150             return $self->caller->do_call($self, $call_object);
151             }
152            
153             sub DescribeAllComplianceByConfigRule {
154             my $self = shift;
155              
156             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
157             my $result = $self->DescribeComplianceByConfigRule(@_);
158             my $next_result = $result;
159              
160             if (not defined $callback) {
161             while ($next_result->NextToken) {
162             $next_result = $self->DescribeComplianceByConfigRule(@_, NextToken => $next_result->NextToken);
163             push @{ $result->ComplianceByConfigRules }, @{ $next_result->ComplianceByConfigRules };
164             }
165             return $result;
166             } else {
167             while ($result->NextToken) {
168             $callback->($_ => 'ComplianceByConfigRules') foreach (@{ $result->ComplianceByConfigRules });
169             $result = $self->DescribeComplianceByConfigRule(@_, NextToken => $result->NextToken);
170             }
171             $callback->($_ => 'ComplianceByConfigRules') foreach (@{ $result->ComplianceByConfigRules });
172             }
173              
174             return undef
175             }
176             sub DescribeAllComplianceByResource {
177             my $self = shift;
178              
179             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
180             my $result = $self->DescribeComplianceByResource(@_);
181             my $next_result = $result;
182              
183             if (not defined $callback) {
184             while ($next_result->NextToken) {
185             $next_result = $self->DescribeComplianceByResource(@_, NextToken => $next_result->NextToken);
186             push @{ $result->ComplianceByResources }, @{ $next_result->ComplianceByResources };
187             }
188             return $result;
189             } else {
190             while ($result->NextToken) {
191             $callback->($_ => 'ComplianceByResources') foreach (@{ $result->ComplianceByResources });
192             $result = $self->DescribeComplianceByResource(@_, NextToken => $result->NextToken);
193             }
194             $callback->($_ => 'ComplianceByResources') foreach (@{ $result->ComplianceByResources });
195             }
196              
197             return undef
198             }
199             sub DescribeAllConfigRules {
200             my $self = shift;
201              
202             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
203             my $result = $self->DescribeConfigRules(@_);
204             my $next_result = $result;
205              
206             if (not defined $callback) {
207             while ($next_result->NextToken) {
208             $next_result = $self->DescribeConfigRules(@_, NextToken => $next_result->NextToken);
209             push @{ $result->ConfigRules }, @{ $next_result->ConfigRules };
210             }
211             return $result;
212             } else {
213             while ($result->NextToken) {
214             $callback->($_ => 'ConfigRules') foreach (@{ $result->ConfigRules });
215             $result = $self->DescribeConfigRules(@_, NextToken => $result->NextToken);
216             }
217             $callback->($_ => 'ConfigRules') foreach (@{ $result->ConfigRules });
218             }
219              
220             return undef
221             }
222             sub GetAllComplianceDetailsByConfigRule {
223             my $self = shift;
224              
225             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
226             my $result = $self->GetComplianceDetailsByConfigRule(@_);
227             my $next_result = $result;
228              
229             if (not defined $callback) {
230             while ($next_result->NextToken) {
231             $next_result = $self->GetComplianceDetailsByConfigRule(@_, NextToken => $next_result->NextToken);
232             push @{ $result->EvaluationResults }, @{ $next_result->EvaluationResults };
233             }
234             return $result;
235             } else {
236             while ($result->NextToken) {
237             $callback->($_ => 'EvaluationResults') foreach (@{ $result->EvaluationResults });
238             $result = $self->GetComplianceDetailsByConfigRule(@_, NextToken => $result->NextToken);
239             }
240             $callback->($_ => 'EvaluationResults') foreach (@{ $result->EvaluationResults });
241             }
242              
243             return undef
244             }
245             sub GetAllComplianceDetailsByResource {
246             my $self = shift;
247              
248             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
249             my $result = $self->GetComplianceDetailsByResource(@_);
250             my $next_result = $result;
251              
252             if (not defined $callback) {
253             while ($next_result->NextToken) {
254             $next_result = $self->GetComplianceDetailsByResource(@_, NextToken => $next_result->NextToken);
255             push @{ $result->EvaluationResults }, @{ $next_result->EvaluationResults };
256             }
257             return $result;
258             } else {
259             while ($result->NextToken) {
260             $callback->($_ => 'EvaluationResults') foreach (@{ $result->EvaluationResults });
261             $result = $self->GetComplianceDetailsByResource(@_, NextToken => $result->NextToken);
262             }
263             $callback->($_ => 'EvaluationResults') foreach (@{ $result->EvaluationResults });
264             }
265              
266             return undef
267             }
268             sub GetAllResourceConfigHistory {
269             my $self = shift;
270              
271             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
272             my $result = $self->GetResourceConfigHistory(@_);
273             my $next_result = $result;
274              
275             if (not defined $callback) {
276             while ($next_result->nextToken) {
277             $next_result = $self->GetResourceConfigHistory(@_, nextToken => $next_result->nextToken);
278             push @{ $result->configurationItems }, @{ $next_result->configurationItems };
279             }
280             return $result;
281             } else {
282             while ($result->nextToken) {
283             $callback->($_ => 'configurationItems') foreach (@{ $result->configurationItems });
284             $result = $self->GetResourceConfigHistory(@_, nextToken => $result->nextToken);
285             }
286             $callback->($_ => 'configurationItems') foreach (@{ $result->configurationItems });
287             }
288              
289             return undef
290             }
291             sub ListAllDiscoveredResources {
292             my $self = shift;
293              
294             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
295             my $result = $self->ListDiscoveredResources(@_);
296             my $next_result = $result;
297              
298             if (not defined $callback) {
299             while ($next_result->nextToken) {
300             $next_result = $self->ListDiscoveredResources(@_, nextToken => $next_result->nextToken);
301             push @{ $result->resourceIdentifiers }, @{ $next_result->resourceIdentifiers };
302             }
303             return $result;
304             } else {
305             while ($result->nextToken) {
306             $callback->($_ => 'resourceIdentifiers') foreach (@{ $result->resourceIdentifiers });
307             $result = $self->ListDiscoveredResources(@_, nextToken => $result->nextToken);
308             }
309             $callback->($_ => 'resourceIdentifiers') foreach (@{ $result->resourceIdentifiers });
310             }
311              
312             return undef
313             }
314              
315              
316             sub operations { qw/DeleteConfigRule DeleteConfigurationRecorder DeleteDeliveryChannel DeleteEvaluationResults DeliverConfigSnapshot DescribeComplianceByConfigRule DescribeComplianceByResource DescribeConfigRuleEvaluationStatus DescribeConfigRules DescribeConfigurationRecorders DescribeConfigurationRecorderStatus DescribeDeliveryChannels DescribeDeliveryChannelStatus GetComplianceDetailsByConfigRule GetComplianceDetailsByResource GetComplianceSummaryByConfigRule GetComplianceSummaryByResourceType GetDiscoveredResourceCounts GetResourceConfigHistory ListDiscoveredResources PutConfigRule PutConfigurationRecorder PutDeliveryChannel PutEvaluations StartConfigRulesEvaluation StartConfigurationRecorder StopConfigurationRecorder / }
317              
318             1;
319              
320             ### main pod documentation begin ###
321              
322             =head1 NAME
323              
324             Paws::Config - Perl Interface to AWS AWS Config
325              
326             =head1 SYNOPSIS
327              
328             use Paws;
329              
330             my $obj = Paws->service('Config');
331             my $res = $obj->Method(
332             Arg1 => $val1,
333             Arg2 => [ 'V1', 'V2' ],
334             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
335             # of the arguments type
336             Arg3 => { Att1 => 'Val1' },
337             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
338             # the constructor of the arguments type
339             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
340             );
341              
342             =head1 DESCRIPTION
343              
344             AWS Config
345              
346             AWS Config provides a way to keep track of the configurations of all
347             the AWS resources associated with your AWS account. You can use AWS
348             Config to get the current and historical configurations of each AWS
349             resource and also to get information about the relationship between the
350             resources. An AWS resource can be an Amazon Compute Cloud (Amazon EC2)
351             instance, an Elastic Block Store (EBS) volume, an Elastic network
352             Interface (ENI), or a security group. For a complete list of resources
353             currently supported by AWS Config, see Supported AWS Resources.
354              
355             You can access and manage AWS Config through the AWS Management
356             Console, the AWS Command Line Interface (AWS CLI), the AWS Config API,
357             or the AWS SDKs for AWS Config
358              
359             This reference guide contains documentation for the AWS Config API and
360             the AWS CLI commands that you can use to manage AWS Config.
361              
362             The AWS Config API uses the Signature Version 4 protocol for signing
363             requests. For more information about how to sign a request with this
364             protocol, see Signature Version 4 Signing Process.
365              
366             For detailed information about AWS Config features and their associated
367             actions or commands, as well as how to work with AWS Management
368             Console, see What Is AWS Config? in the I<AWS Config Developer Guide>.
369              
370             =head1 METHODS
371              
372             =head2 DeleteConfigRule(ConfigRuleName => Str)
373              
374             Each argument is described in detail in: L<Paws::Config::DeleteConfigRule>
375              
376             Returns: nothing
377              
378             Deletes the specified AWS Config rule and all of its evaluation
379             results.
380              
381             AWS Config sets the state of a rule to C<DELETING> until the deletion
382             is complete. You cannot update a rule while it is in this state. If you
383             make a C<PutConfigRule> or C<DeleteConfigRule> request for the rule,
384             you will receive a C<ResourceInUseException>.
385              
386             You can check the state of a rule by using the C<DescribeConfigRules>
387             request.
388              
389              
390             =head2 DeleteConfigurationRecorder(ConfigurationRecorderName => Str)
391              
392             Each argument is described in detail in: L<Paws::Config::DeleteConfigurationRecorder>
393              
394             Returns: nothing
395              
396             Deletes the configuration recorder.
397              
398             After the configuration recorder is deleted, AWS Config will not record
399             resource configuration changes until you create a new configuration
400             recorder.
401              
402             This action does not delete the configuration information that was
403             previously recorded. You will be able to access the previously recorded
404             information by using the C<GetResourceConfigHistory> action, but you
405             will not be able to access this information in the AWS Config console
406             until you create a new configuration recorder.
407              
408              
409             =head2 DeleteDeliveryChannel(DeliveryChannelName => Str)
410              
411             Each argument is described in detail in: L<Paws::Config::DeleteDeliveryChannel>
412              
413             Returns: nothing
414              
415             Deletes the delivery channel.
416              
417             Before you can delete the delivery channel, you must stop the
418             configuration recorder by using the StopConfigurationRecorder action.
419              
420              
421             =head2 DeleteEvaluationResults(ConfigRuleName => Str)
422              
423             Each argument is described in detail in: L<Paws::Config::DeleteEvaluationResults>
424              
425             Returns: a L<Paws::Config::DeleteEvaluationResultsResponse> instance
426              
427             Deletes the evaluation results for the specified Config rule. You can
428             specify one Config rule per request. After you delete the evaluation
429             results, you can call the StartConfigRulesEvaluation API to start
430             evaluating your AWS resources against the rule.
431              
432              
433             =head2 DeliverConfigSnapshot(DeliveryChannelName => Str)
434              
435             Each argument is described in detail in: L<Paws::Config::DeliverConfigSnapshot>
436              
437             Returns: a L<Paws::Config::DeliverConfigSnapshotResponse> instance
438              
439             Schedules delivery of a configuration snapshot to the Amazon S3 bucket
440             in the specified delivery channel. After the delivery has started, AWS
441             Config sends following notifications using an Amazon SNS topic that you
442             have specified.
443              
444             =over
445              
446             =item *
447              
448             Notification of starting the delivery.
449              
450             =item *
451              
452             Notification of delivery completed, if the delivery was successfully
453             completed.
454              
455             =item *
456              
457             Notification of delivery failure, if the delivery failed to complete.
458              
459             =back
460              
461              
462              
463             =head2 DescribeComplianceByConfigRule([ComplianceTypes => ArrayRef[Str|Undef], ConfigRuleNames => ArrayRef[Str|Undef], NextToken => Str])
464              
465             Each argument is described in detail in: L<Paws::Config::DescribeComplianceByConfigRule>
466              
467             Returns: a L<Paws::Config::DescribeComplianceByConfigRuleResponse> instance
468              
469             Indicates whether the specified AWS Config rules are compliant. If a
470             rule is noncompliant, this action returns the number of AWS resources
471             that do not comply with the rule.
472              
473             A rule is compliant if all of the evaluated resources comply with it,
474             and it is noncompliant if any of these resources do not comply.
475              
476             If AWS Config has no current evaluation results for the rule, it
477             returns C<INSUFFICIENT_DATA>. This result might indicate one of the
478             following conditions:
479              
480             =over
481              
482             =item *
483              
484             AWS Config has never invoked an evaluation for the rule. To check
485             whether it has, use the C<DescribeConfigRuleEvaluationStatus> action to
486             get the C<LastSuccessfulInvocationTime> and
487             C<LastFailedInvocationTime>.
488              
489             =item *
490              
491             The rule's AWS Lambda function is failing to send evaluation results to
492             AWS Config. Verify that the role that you assigned to your
493             configuration recorder includes the C<config:PutEvaluations>
494             permission. If the rule is a custom rule, verify that the AWS Lambda
495             execution role includes the C<config:PutEvaluations> permission.
496              
497             =item *
498              
499             The rule's AWS Lambda function has returned C<NOT_APPLICABLE> for all
500             evaluation results. This can occur if the resources were deleted or
501             removed from the rule's scope.
502              
503             =back
504              
505              
506              
507             =head2 DescribeComplianceByResource([ComplianceTypes => ArrayRef[Str|Undef], Limit => Int, NextToken => Str, ResourceId => Str, ResourceType => Str])
508              
509             Each argument is described in detail in: L<Paws::Config::DescribeComplianceByResource>
510              
511             Returns: a L<Paws::Config::DescribeComplianceByResourceResponse> instance
512              
513             Indicates whether the specified AWS resources are compliant. If a
514             resource is noncompliant, this action returns the number of AWS Config
515             rules that the resource does not comply with.
516              
517             A resource is compliant if it complies with all the AWS Config rules
518             that evaluate it. It is noncompliant if it does not comply with one or
519             more of these rules.
520              
521             If AWS Config has no current evaluation results for the resource, it
522             returns C<INSUFFICIENT_DATA>. This result might indicate one of the
523             following conditions about the rules that evaluate the resource:
524              
525             =over
526              
527             =item *
528              
529             AWS Config has never invoked an evaluation for the rule. To check
530             whether it has, use the C<DescribeConfigRuleEvaluationStatus> action to
531             get the C<LastSuccessfulInvocationTime> and
532             C<LastFailedInvocationTime>.
533              
534             =item *
535              
536             The rule's AWS Lambda function is failing to send evaluation results to
537             AWS Config. Verify that the role that you assigned to your
538             configuration recorder includes the C<config:PutEvaluations>
539             permission. If the rule is a custom rule, verify that the AWS Lambda
540             execution role includes the C<config:PutEvaluations> permission.
541              
542             =item *
543              
544             The rule's AWS Lambda function has returned C<NOT_APPLICABLE> for all
545             evaluation results. This can occur if the resources were deleted or
546             removed from the rule's scope.
547              
548             =back
549              
550              
551              
552             =head2 DescribeConfigRuleEvaluationStatus([ConfigRuleNames => ArrayRef[Str|Undef], Limit => Int, NextToken => Str])
553              
554             Each argument is described in detail in: L<Paws::Config::DescribeConfigRuleEvaluationStatus>
555              
556             Returns: a L<Paws::Config::DescribeConfigRuleEvaluationStatusResponse> instance
557              
558             Returns status information for each of your AWS managed Config rules.
559             The status includes information such as the last time AWS Config
560             invoked the rule, the last time AWS Config failed to invoke the rule,
561             and the related error for the last failure.
562              
563              
564             =head2 DescribeConfigRules([ConfigRuleNames => ArrayRef[Str|Undef], NextToken => Str])
565              
566             Each argument is described in detail in: L<Paws::Config::DescribeConfigRules>
567              
568             Returns: a L<Paws::Config::DescribeConfigRulesResponse> instance
569              
570             Returns details about your AWS Config rules.
571              
572              
573             =head2 DescribeConfigurationRecorders([ConfigurationRecorderNames => ArrayRef[Str|Undef]])
574              
575             Each argument is described in detail in: L<Paws::Config::DescribeConfigurationRecorders>
576              
577             Returns: a L<Paws::Config::DescribeConfigurationRecordersResponse> instance
578              
579             Returns the details for the specified configuration recorders. If the
580             configuration recorder is not specified, this action returns the
581             details for all configuration recorders associated with the account.
582              
583             Currently, you can specify only one configuration recorder per region
584             in your account.
585              
586              
587             =head2 DescribeConfigurationRecorderStatus([ConfigurationRecorderNames => ArrayRef[Str|Undef]])
588              
589             Each argument is described in detail in: L<Paws::Config::DescribeConfigurationRecorderStatus>
590              
591             Returns: a L<Paws::Config::DescribeConfigurationRecorderStatusResponse> instance
592              
593             Returns the current status of the specified configuration recorder. If
594             a configuration recorder is not specified, this action returns the
595             status of all configuration recorder associated with the account.
596              
597             Currently, you can specify only one configuration recorder per region
598             in your account.
599              
600              
601             =head2 DescribeDeliveryChannels([DeliveryChannelNames => ArrayRef[Str|Undef]])
602              
603             Each argument is described in detail in: L<Paws::Config::DescribeDeliveryChannels>
604              
605             Returns: a L<Paws::Config::DescribeDeliveryChannelsResponse> instance
606              
607             Returns details about the specified delivery channel. If a delivery
608             channel is not specified, this action returns the details of all
609             delivery channels associated with the account.
610              
611             Currently, you can specify only one delivery channel per region in your
612             account.
613              
614              
615             =head2 DescribeDeliveryChannelStatus([DeliveryChannelNames => ArrayRef[Str|Undef]])
616              
617             Each argument is described in detail in: L<Paws::Config::DescribeDeliveryChannelStatus>
618              
619             Returns: a L<Paws::Config::DescribeDeliveryChannelStatusResponse> instance
620              
621             Returns the current status of the specified delivery channel. If a
622             delivery channel is not specified, this action returns the current
623             status of all delivery channels associated with the account.
624              
625             Currently, you can specify only one delivery channel per region in your
626             account.
627              
628              
629             =head2 GetComplianceDetailsByConfigRule(ConfigRuleName => Str, [ComplianceTypes => ArrayRef[Str|Undef], Limit => Int, NextToken => Str])
630              
631             Each argument is described in detail in: L<Paws::Config::GetComplianceDetailsByConfigRule>
632              
633             Returns: a L<Paws::Config::GetComplianceDetailsByConfigRuleResponse> instance
634              
635             Returns the evaluation results for the specified AWS Config rule. The
636             results indicate which AWS resources were evaluated by the rule, when
637             each resource was last evaluated, and whether each resource complies
638             with the rule.
639              
640              
641             =head2 GetComplianceDetailsByResource(ResourceId => Str, ResourceType => Str, [ComplianceTypes => ArrayRef[Str|Undef], NextToken => Str])
642              
643             Each argument is described in detail in: L<Paws::Config::GetComplianceDetailsByResource>
644              
645             Returns: a L<Paws::Config::GetComplianceDetailsByResourceResponse> instance
646              
647             Returns the evaluation results for the specified AWS resource. The
648             results indicate which AWS Config rules were used to evaluate the
649             resource, when each rule was last used, and whether the resource
650             complies with each rule.
651              
652              
653             =head2 GetComplianceSummaryByConfigRule( => )
654              
655             Each argument is described in detail in: L<Paws::Config::GetComplianceSummaryByConfigRule>
656              
657             Returns: a L<Paws::Config::GetComplianceSummaryByConfigRuleResponse> instance
658              
659             Returns the number of AWS Config rules that are compliant and
660             noncompliant, up to a maximum of 25 for each.
661              
662              
663             =head2 GetComplianceSummaryByResourceType([ResourceTypes => ArrayRef[Str|Undef]])
664              
665             Each argument is described in detail in: L<Paws::Config::GetComplianceSummaryByResourceType>
666              
667             Returns: a L<Paws::Config::GetComplianceSummaryByResourceTypeResponse> instance
668              
669             Returns the number of resources that are compliant and the number that
670             are noncompliant. You can specify one or more resource types to get
671             these numbers for each resource type. The maximum number returned is
672             100.
673              
674              
675             =head2 GetDiscoveredResourceCounts([Limit => Int, NextToken => Str, ResourceTypes => ArrayRef[Str|Undef]])
676              
677             Each argument is described in detail in: L<Paws::Config::GetDiscoveredResourceCounts>
678              
679             Returns: a L<Paws::Config::GetDiscoveredResourceCountsResponse> instance
680              
681             Returns the resource types, the number of each resource type, and the
682             total number of resources that AWS Config is recording in this region
683             for your AWS account.
684              
685             B<Example>
686              
687             =over
688              
689             =item 1.
690              
691             AWS Config is recording three resource types in the US East (Ohio)
692             Region for your account: 25 EC2 instances, 20 IAM users, and 15 S3
693             buckets.
694              
695             =item 2.
696              
697             You make a call to the C<GetDiscoveredResourceCounts> action and
698             specify that you want all resource types.
699              
700             =item 3.
701              
702             AWS Config returns the following:
703              
704             =over
705              
706             =item *
707              
708             The resource types (EC2 instances, IAM users, and S3 buckets)
709              
710             =item *
711              
712             The number of each resource type (25, 20, and 15)
713              
714             =item *
715              
716             The total number of all resources (60)
717              
718             =back
719              
720             =back
721              
722             The response is paginated. By default, AWS Config lists 100
723             ResourceCount objects on each page. You can customize this number with
724             the C<limit> parameter. The response includes a C<nextToken> string. To
725             get the next page of results, run the request again and specify the
726             string for the C<nextToken> parameter.
727              
728             If you make a call to the GetDiscoveredResourceCounts action, you may
729             not immediately receive resource counts in the following situations:
730              
731             =over
732              
733             =item *
734              
735             You are a new AWS Config customer
736              
737             =item *
738              
739             You just enabled resource recording
740              
741             =back
742              
743             It may take a few minutes for AWS Config to record and count your
744             resources. Wait a few minutes and then retry the
745             GetDiscoveredResourceCounts action.
746              
747              
748             =head2 GetResourceConfigHistory(ResourceId => Str, ResourceType => Str, [ChronologicalOrder => Str, EarlierTime => Str, LaterTime => Str, Limit => Int, NextToken => Str])
749              
750             Each argument is described in detail in: L<Paws::Config::GetResourceConfigHistory>
751              
752             Returns: a L<Paws::Config::GetResourceConfigHistoryResponse> instance
753              
754             Returns a list of configuration items for the specified resource. The
755             list contains details about each state of the resource during the
756             specified time interval.
757              
758             The response is paginated. By default, AWS Config returns a limit of 10
759             configuration items per page. You can customize this number with the
760             C<limit> parameter. The response includes a C<nextToken> string. To get
761             the next page of results, run the request again and specify the string
762             for the C<nextToken> parameter.
763              
764             Each call to the API is limited to span a duration of seven days. It is
765             likely that the number of records returned is smaller than the
766             specified C<limit>. In such cases, you can make another call, using the
767             C<nextToken>.
768              
769              
770             =head2 ListDiscoveredResources(ResourceType => Str, [IncludeDeletedResources => Bool, Limit => Int, NextToken => Str, ResourceIds => ArrayRef[Str|Undef], ResourceName => Str])
771              
772             Each argument is described in detail in: L<Paws::Config::ListDiscoveredResources>
773              
774             Returns: a L<Paws::Config::ListDiscoveredResourcesResponse> instance
775              
776             Accepts a resource type and returns a list of resource identifiers for
777             the resources of that type. A resource identifier includes the resource
778             type, ID, and (if available) the custom resource name. The results
779             consist of resources that AWS Config has discovered, including those
780             that AWS Config is not currently recording. You can narrow the results
781             to include only resources that have specific resource IDs or a resource
782             name.
783              
784             You can specify either resource IDs or a resource name but not both in
785             the same request.
786              
787             The response is paginated. By default, AWS Config lists 100 resource
788             identifiers on each page. You can customize this number with the
789             C<limit> parameter. The response includes a C<nextToken> string. To get
790             the next page of results, run the request again and specify the string
791             for the C<nextToken> parameter.
792              
793              
794             =head2 PutConfigRule(ConfigRule => L<Paws::Config::ConfigRule>)
795              
796             Each argument is described in detail in: L<Paws::Config::PutConfigRule>
797              
798             Returns: nothing
799              
800             Adds or updates an AWS Config rule for evaluating whether your AWS
801             resources comply with your desired configurations.
802              
803             You can use this action for custom Config rules and AWS managed Config
804             rules. A custom Config rule is a rule that you develop and maintain. An
805             AWS managed Config rule is a customizable, predefined rule that AWS
806             Config provides.
807              
808             If you are adding a new custom Config rule, you must first create the
809             AWS Lambda function that the rule invokes to evaluate your resources.
810             When you use the C<PutConfigRule> action to add the rule to AWS Config,
811             you must specify the Amazon Resource Name (ARN) that AWS Lambda assigns
812             to the function. Specify the ARN for the C<SourceIdentifier> key. This
813             key is part of the C<Source> object, which is part of the C<ConfigRule>
814             object.
815              
816             If you are adding an AWS managed Config rule, specify the rule's
817             identifier for the C<SourceIdentifier> key. To reference AWS managed
818             Config rule identifiers, see About AWS Managed Config Rules.
819              
820             For any new rule that you add, specify the C<ConfigRuleName> in the
821             C<ConfigRule> object. Do not specify the C<ConfigRuleArn> or the
822             C<ConfigRuleId>. These values are generated by AWS Config for new
823             rules.
824              
825             If you are updating a rule that you added previously, you can specify
826             the rule by C<ConfigRuleName>, C<ConfigRuleId>, or C<ConfigRuleArn> in
827             the C<ConfigRule> data type that you use in this request.
828              
829             The maximum number of rules that AWS Config supports is 50.
830              
831             For more information about requesting a rule limit increase, see AWS
832             Config Limits in the I<AWS General Reference Guide>.
833              
834             For more information about developing and using AWS Config rules, see
835             Evaluating AWS Resource Configurations with AWS Config in the I<AWS
836             Config Developer Guide>.
837              
838              
839             =head2 PutConfigurationRecorder(ConfigurationRecorder => L<Paws::Config::ConfigurationRecorder>)
840              
841             Each argument is described in detail in: L<Paws::Config::PutConfigurationRecorder>
842              
843             Returns: nothing
844              
845             Creates a new configuration recorder to record the selected resource
846             configurations.
847              
848             You can use this action to change the role C<roleARN> and/or the
849             C<recordingGroup> of an existing recorder. To change the role, call the
850             action on the existing configuration recorder and specify a role.
851              
852             Currently, you can specify only one configuration recorder per region
853             in your account.
854              
855             If C<ConfigurationRecorder> does not have the B<recordingGroup>
856             parameter specified, the default is to record all supported resource
857             types.
858              
859              
860             =head2 PutDeliveryChannel(DeliveryChannel => L<Paws::Config::DeliveryChannel>)
861              
862             Each argument is described in detail in: L<Paws::Config::PutDeliveryChannel>
863              
864             Returns: nothing
865              
866             Creates a delivery channel object to deliver configuration information
867             to an Amazon S3 bucket and Amazon SNS topic.
868              
869             Before you can create a delivery channel, you must create a
870             configuration recorder.
871              
872             You can use this action to change the Amazon S3 bucket or an Amazon SNS
873             topic of the existing delivery channel. To change the Amazon S3 bucket
874             or an Amazon SNS topic, call this action and specify the changed values
875             for the S3 bucket and the SNS topic. If you specify a different value
876             for either the S3 bucket or the SNS topic, this action will keep the
877             existing value for the parameter that is not changed.
878              
879             You can have only one delivery channel per region in your account.
880              
881              
882             =head2 PutEvaluations(ResultToken => Str, [Evaluations => ArrayRef[L<Paws::Config::Evaluation>], TestMode => Bool])
883              
884             Each argument is described in detail in: L<Paws::Config::PutEvaluations>
885              
886             Returns: a L<Paws::Config::PutEvaluationsResponse> instance
887              
888             Used by an AWS Lambda function to deliver evaluation results to AWS
889             Config. This action is required in every AWS Lambda function that is
890             invoked by an AWS Config rule.
891              
892              
893             =head2 StartConfigRulesEvaluation([ConfigRuleNames => ArrayRef[Str|Undef]])
894              
895             Each argument is described in detail in: L<Paws::Config::StartConfigRulesEvaluation>
896              
897             Returns: a L<Paws::Config::StartConfigRulesEvaluationResponse> instance
898              
899             Runs an on-demand evaluation for the specified Config rules against the
900             last known configuration state of the resources. Use
901             C<StartConfigRulesEvaluation> when you want to test a rule that you
902             updated is working as expected. C<StartConfigRulesEvaluation> does not
903             re-record the latest configuration state for your resources; it re-runs
904             an evaluation against the last known state of your resources.
905              
906             You can specify up to 25 Config rules per request.
907              
908             An existing C<StartConfigRulesEvaluation> call must complete for the
909             specified rules before you can call the API again. If you chose to have
910             AWS Config stream to an Amazon SNS topic, you will receive a
911             C<ConfigRuleEvaluationStarted> notification when the evaluation starts.
912              
913             You don't need to call the C<StartConfigRulesEvaluation> API to run an
914             evaluation for a new rule. When you create a new rule, AWS Config
915             automatically evaluates your resources against the rule.
916              
917             The C<StartConfigRulesEvaluation> API is useful if you want to run
918             on-demand evaluations, such as the following example:
919              
920             =over
921              
922             =item 1.
923              
924             You have a custom rule that evaluates your IAM resources every 24
925             hours.
926              
927             =item 2.
928              
929             You update your Lambda function to add additional conditions to your
930             rule.
931              
932             =item 3.
933              
934             Instead of waiting for the next periodic evaluation, you call the
935             C<StartConfigRulesEvaluation> API.
936              
937             =item 4.
938              
939             AWS Config invokes your Lambda function and evaluates your IAM
940             resources.
941              
942             =item 5.
943              
944             Your custom rule will still run periodic evaluations every 24 hours.
945              
946             =back
947              
948              
949              
950             =head2 StartConfigurationRecorder(ConfigurationRecorderName => Str)
951              
952             Each argument is described in detail in: L<Paws::Config::StartConfigurationRecorder>
953              
954             Returns: nothing
955              
956             Starts recording configurations of the AWS resources you have selected
957             to record in your AWS account.
958              
959             You must have created at least one delivery channel to successfully
960             start the configuration recorder.
961              
962              
963             =head2 StopConfigurationRecorder(ConfigurationRecorderName => Str)
964              
965             Each argument is described in detail in: L<Paws::Config::StopConfigurationRecorder>
966              
967             Returns: nothing
968              
969             Stops recording configurations of the AWS resources you have selected
970             to record in your AWS account.
971              
972              
973              
974              
975             =head1 PAGINATORS
976              
977             Paginator methods are helpers that repetively call methods that return partial results
978              
979             =head2 DescribeAllComplianceByConfigRule(sub { },[ComplianceTypes => ArrayRef[Str|Undef], ConfigRuleNames => ArrayRef[Str|Undef], NextToken => Str])
980              
981             =head2 DescribeAllComplianceByConfigRule([ComplianceTypes => ArrayRef[Str|Undef], ConfigRuleNames => ArrayRef[Str|Undef], NextToken => Str])
982              
983              
984             If passed a sub as first parameter, it will call the sub for each element found in :
985              
986             - ComplianceByConfigRules, passing the object as the first parameter, and the string 'ComplianceByConfigRules' as the second parameter
987              
988             If not, it will return a a L<Paws::Config::DescribeComplianceByConfigRuleResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
989              
990              
991             =head2 DescribeAllComplianceByResource(sub { },[ComplianceTypes => ArrayRef[Str|Undef], Limit => Int, NextToken => Str, ResourceId => Str, ResourceType => Str])
992              
993             =head2 DescribeAllComplianceByResource([ComplianceTypes => ArrayRef[Str|Undef], Limit => Int, NextToken => Str, ResourceId => Str, ResourceType => Str])
994              
995              
996             If passed a sub as first parameter, it will call the sub for each element found in :
997              
998             - ComplianceByResources, passing the object as the first parameter, and the string 'ComplianceByResources' as the second parameter
999              
1000             If not, it will return a a L<Paws::Config::DescribeComplianceByResourceResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1001              
1002              
1003             =head2 DescribeAllConfigRules(sub { },[ConfigRuleNames => ArrayRef[Str|Undef], NextToken => Str])
1004              
1005             =head2 DescribeAllConfigRules([ConfigRuleNames => ArrayRef[Str|Undef], NextToken => Str])
1006              
1007              
1008             If passed a sub as first parameter, it will call the sub for each element found in :
1009              
1010             - ConfigRules, passing the object as the first parameter, and the string 'ConfigRules' as the second parameter
1011              
1012             If not, it will return a a L<Paws::Config::DescribeConfigRulesResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1013              
1014              
1015             =head2 GetAllComplianceDetailsByConfigRule(sub { },ConfigRuleName => Str, [ComplianceTypes => ArrayRef[Str|Undef], Limit => Int, NextToken => Str])
1016              
1017             =head2 GetAllComplianceDetailsByConfigRule(ConfigRuleName => Str, [ComplianceTypes => ArrayRef[Str|Undef], Limit => Int, NextToken => Str])
1018              
1019              
1020             If passed a sub as first parameter, it will call the sub for each element found in :
1021              
1022             - EvaluationResults, passing the object as the first parameter, and the string 'EvaluationResults' as the second parameter
1023              
1024             If not, it will return a a L<Paws::Config::GetComplianceDetailsByConfigRuleResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1025              
1026              
1027             =head2 GetAllComplianceDetailsByResource(sub { },ResourceId => Str, ResourceType => Str, [ComplianceTypes => ArrayRef[Str|Undef], NextToken => Str])
1028              
1029             =head2 GetAllComplianceDetailsByResource(ResourceId => Str, ResourceType => Str, [ComplianceTypes => ArrayRef[Str|Undef], NextToken => Str])
1030              
1031              
1032             If passed a sub as first parameter, it will call the sub for each element found in :
1033              
1034             - EvaluationResults, passing the object as the first parameter, and the string 'EvaluationResults' as the second parameter
1035              
1036             If not, it will return a a L<Paws::Config::GetComplianceDetailsByResourceResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1037              
1038              
1039             =head2 GetAllResourceConfigHistory(sub { },ResourceId => Str, ResourceType => Str, [ChronologicalOrder => Str, EarlierTime => Str, LaterTime => Str, Limit => Int, NextToken => Str])
1040              
1041             =head2 GetAllResourceConfigHistory(ResourceId => Str, ResourceType => Str, [ChronologicalOrder => Str, EarlierTime => Str, LaterTime => Str, Limit => Int, NextToken => Str])
1042              
1043              
1044             If passed a sub as first parameter, it will call the sub for each element found in :
1045              
1046             - configurationItems, passing the object as the first parameter, and the string 'configurationItems' as the second parameter
1047              
1048             If not, it will return a a L<Paws::Config::GetResourceConfigHistoryResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1049              
1050              
1051             =head2 ListAllDiscoveredResources(sub { },ResourceType => Str, [IncludeDeletedResources => Bool, Limit => Int, NextToken => Str, ResourceIds => ArrayRef[Str|Undef], ResourceName => Str])
1052              
1053             =head2 ListAllDiscoveredResources(ResourceType => Str, [IncludeDeletedResources => Bool, Limit => Int, NextToken => Str, ResourceIds => ArrayRef[Str|Undef], ResourceName => Str])
1054              
1055              
1056             If passed a sub as first parameter, it will call the sub for each element found in :
1057              
1058             - resourceIdentifiers, passing the object as the first parameter, and the string 'resourceIdentifiers' as the second parameter
1059              
1060             If not, it will return a a L<Paws::Config::ListDiscoveredResourcesResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1061              
1062              
1063              
1064              
1065              
1066             =head1 SEE ALSO
1067              
1068             This service class forms part of L<Paws>
1069              
1070             =head1 BUGS and CONTRIBUTIONS
1071              
1072             The source code is located here: https://github.com/pplu/aws-sdk-perl
1073              
1074             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
1075              
1076             =cut
1077