blib/lib/Paws/WAFV2.pm untested

filter: Statementstmt 0.0% 0 / 135 Branchbran n/a Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 47 Podpod 0.0% 0 / 46 totaltotal 0.0% 0 / 228 CC 1 SCAR 6.9
CC
1
Cov
0%
service
2.0
signing_name
2.0
version
2.0
CRAP 2.0
1 package Paws::WAFV2;
2 use Moose;
3 sub service { 'wafv2' }
4 sub signing_name { 'wafv2' }
5 sub version { '2019-07-29' }
6 sub target_prefix { 'AWSWAF_20190729' }
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 AssociateWebACL {
19 my $self = shift;
20 my $call_object = $self->new_with_coercions('Paws::WAFV2::AssociateWebACL', @_);
21 return $self->caller->do_call($self, $call_object);
22 }
23 sub CheckCapacity {
24 my $self = shift;
25 my $call_object = $self->new_with_coercions('Paws::WAFV2::CheckCapacity', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub CreateIPSet {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::WAFV2::CreateIPSet', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub CreateRegexPatternSet {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::WAFV2::CreateRegexPatternSet', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub CreateRuleGroup {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::WAFV2::CreateRuleGroup', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub CreateWebACL {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::WAFV2::CreateWebACL', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub DeleteFirewallManagerRuleGroups {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::WAFV2::DeleteFirewallManagerRuleGroups', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub DeleteIPSet {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::WAFV2::DeleteIPSet', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub DeleteLoggingConfiguration {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::WAFV2::DeleteLoggingConfiguration', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub DeletePermissionPolicy {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::WAFV2::DeletePermissionPolicy', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub DeleteRegexPatternSet {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::WAFV2::DeleteRegexPatternSet', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub DeleteRuleGroup {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::WAFV2::DeleteRuleGroup', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub DeleteWebACL {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::WAFV2::DeleteWebACL', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub DescribeManagedRuleGroup {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::WAFV2::DescribeManagedRuleGroup', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub DisassociateWebACL {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::WAFV2::DisassociateWebACL', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93 sub GetIPSet {
94 my $self = shift;
95 my $call_object = $self->new_with_coercions('Paws::WAFV2::GetIPSet', @_);
96 return $self->caller->do_call($self, $call_object);
97 }
98 sub GetLoggingConfiguration {
99 my $self = shift;
100 my $call_object = $self->new_with_coercions('Paws::WAFV2::GetLoggingConfiguration', @_);
101 return $self->caller->do_call($self, $call_object);
102 }
103 sub GetPermissionPolicy {
104 my $self = shift;
105 my $call_object = $self->new_with_coercions('Paws::WAFV2::GetPermissionPolicy', @_);
106 return $self->caller->do_call($self, $call_object);
107 }
108 sub GetRateBasedStatementManagedKeys {
109 my $self = shift;
110 my $call_object = $self->new_with_coercions('Paws::WAFV2::GetRateBasedStatementManagedKeys', @_);
111 return $self->caller->do_call($self, $call_object);
112 }
113 sub GetRegexPatternSet {
114 my $self = shift;
115 my $call_object = $self->new_with_coercions('Paws::WAFV2::GetRegexPatternSet', @_);
116 return $self->caller->do_call($self, $call_object);
117 }
118 sub GetRuleGroup {
119 my $self = shift;
120 my $call_object = $self->new_with_coercions('Paws::WAFV2::GetRuleGroup', @_);
121 return $self->caller->do_call($self, $call_object);
122 }
123 sub GetSampledRequests {
124 my $self = shift;
125 my $call_object = $self->new_with_coercions('Paws::WAFV2::GetSampledRequests', @_);
126 return $self->caller->do_call($self, $call_object);
127 }
128 sub GetWebACL {
129 my $self = shift;
130 my $call_object = $self->new_with_coercions('Paws::WAFV2::GetWebACL', @_);
131 return $self->caller->do_call($self, $call_object);
132 }
133 sub GetWebACLForResource {
134 my $self = shift;
135 my $call_object = $self->new_with_coercions('Paws::WAFV2::GetWebACLForResource', @_);
136 return $self->caller->do_call($self, $call_object);
137 }
138 sub ListAvailableManagedRuleGroups {
139 my $self = shift;
140 my $call_object = $self->new_with_coercions('Paws::WAFV2::ListAvailableManagedRuleGroups', @_);
141 return $self->caller->do_call($self, $call_object);
142 }
143 sub ListIPSets {
144 my $self = shift;
145 my $call_object = $self->new_with_coercions('Paws::WAFV2::ListIPSets', @_);
146 return $self->caller->do_call($self, $call_object);
147 }
148 sub ListLoggingConfigurations {
149 my $self = shift;
150 my $call_object = $self->new_with_coercions('Paws::WAFV2::ListLoggingConfigurations', @_);
151 return $self->caller->do_call($self, $call_object);
152 }
153 sub ListRegexPatternSets {
154 my $self = shift;
155 my $call_object = $self->new_with_coercions('Paws::WAFV2::ListRegexPatternSets', @_);
156 return $self->caller->do_call($self, $call_object);
157 }
158 sub ListResourcesForWebACL {
159 my $self = shift;
160 my $call_object = $self->new_with_coercions('Paws::WAFV2::ListResourcesForWebACL', @_);
161 return $self->caller->do_call($self, $call_object);
162 }
163 sub ListRuleGroups {
164 my $self = shift;
165 my $call_object = $self->new_with_coercions('Paws::WAFV2::ListRuleGroups', @_);
166 return $self->caller->do_call($self, $call_object);
167 }
168 sub ListTagsForResource {
169 my $self = shift;
170 my $call_object = $self->new_with_coercions('Paws::WAFV2::ListTagsForResource', @_);
171 return $self->caller->do_call($self, $call_object);
172 }
173 sub ListWebACLs {
174 my $self = shift;
175 my $call_object = $self->new_with_coercions('Paws::WAFV2::ListWebACLs', @_);
176 return $self->caller->do_call($self, $call_object);
177 }
178 sub PutLoggingConfiguration {
179 my $self = shift;
180 my $call_object = $self->new_with_coercions('Paws::WAFV2::PutLoggingConfiguration', @_);
181 return $self->caller->do_call($self, $call_object);
182 }
183 sub PutPermissionPolicy {
184 my $self = shift;
185 my $call_object = $self->new_with_coercions('Paws::WAFV2::PutPermissionPolicy', @_);
186 return $self->caller->do_call($self, $call_object);
187 }
188 sub TagResource {
189 my $self = shift;
190 my $call_object = $self->new_with_coercions('Paws::WAFV2::TagResource', @_);
191 return $self->caller->do_call($self, $call_object);
192 }
193 sub UntagResource {
194 my $self = shift;
195 my $call_object = $self->new_with_coercions('Paws::WAFV2::UntagResource', @_);
196 return $self->caller->do_call($self, $call_object);
197 }
198 sub UpdateIPSet {
199 my $self = shift;
200 my $call_object = $self->new_with_coercions('Paws::WAFV2::UpdateIPSet', @_);
201 return $self->caller->do_call($self, $call_object);
202 }
203 sub UpdateRegexPatternSet {
204 my $self = shift;
205 my $call_object = $self->new_with_coercions('Paws::WAFV2::UpdateRegexPatternSet', @_);
206 return $self->caller->do_call($self, $call_object);
207 }
208 sub UpdateRuleGroup {
209 my $self = shift;
210 my $call_object = $self->new_with_coercions('Paws::WAFV2::UpdateRuleGroup', @_);
211 return $self->caller->do_call($self, $call_object);
212 }
213 sub UpdateWebACL {
214 my $self = shift;
215 my $call_object = $self->new_with_coercions('Paws::WAFV2::UpdateWebACL', @_);
216 return $self->caller->do_call($self, $call_object);
217 }
218
219  
220  
221 sub operations { qw/AssociateWebACL CheckCapacity CreateIPSet CreateRegexPatternSet CreateRuleGroup CreateWebACL DeleteFirewallManagerRuleGroups DeleteIPSet DeleteLoggingConfiguration DeletePermissionPolicy DeleteRegexPatternSet DeleteRuleGroup DeleteWebACL DescribeManagedRuleGroup DisassociateWebACL GetIPSet GetLoggingConfiguration GetPermissionPolicy GetRateBasedStatementManagedKeys GetRegexPatternSet GetRuleGroup GetSampledRequests GetWebACL GetWebACLForResource ListAvailableManagedRuleGroups ListIPSets ListLoggingConfigurations ListRegexPatternSets ListResourcesForWebACL ListRuleGroups ListTagsForResource ListWebACLs PutLoggingConfiguration PutPermissionPolicy TagResource UntagResource UpdateIPSet UpdateRegexPatternSet UpdateRuleGroup UpdateWebACL / }
222  
223 1;
224  
225 ### main pod documentation begin ###
226  
227 =head1 NAME
228  
229 Paws::WAFV2 - Perl Interface to AWS AWS WAFV2
230  
231 =head1 SYNOPSIS
232  
233 use Paws;
234  
235 my $obj = Paws->service('WAFV2');
236 my $res = $obj->Method(
237 Arg1 => $val1,
238 Arg2 => [ 'V1', 'V2' ],
239 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
240 # of the arguments type
241 Arg3 => { Att1 => 'Val1' },
242 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
243 # the constructor of the arguments type
244 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
245 );
246  
247 =head1 DESCRIPTION
248  
249 WAF
250  
251 This is the latest version of the B<WAF> API, released in November,
252 2019. The names of the entities that you use to access this API, like
253 endpoints and namespaces, all have the versioning information added,
254 like "V2" or "v2", to distinguish from the prior version. We recommend
255 migrating your resources to this version, because it has a number of
256 significant improvements.
257  
258 If you used WAF prior to this release, you can't use this WAFV2 API to
259 access any WAF resources that you created before. You can access your
260 old rules, web ACLs, and other WAF resources only through the WAF
261 Classic APIs. The WAF Classic APIs have retained the prior names,
262 endpoints, and namespaces.
263  
264 For information, including how to migrate your WAF resources to this
265 version, see the WAF Developer Guide
266 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
267  
268 WAF is a web application firewall that lets you monitor the HTTP and
269 HTTPS requests that are forwarded to Amazon CloudFront, an Amazon API
270 Gateway REST API, an Application Load Balancer, or an AppSync GraphQL
271 API. WAF also lets you control access to your content. Based on
272 conditions that you specify, such as the IP addresses that requests
273 originate from or the values of query strings, the Amazon API Gateway
274 REST API, CloudFront distribution, the Application Load Balancer, or
275 the AppSync GraphQL API responds to requests either with the requested
276 content or with an HTTP 403 status code (Forbidden). You also can
277 configure CloudFront to return a custom error page when a request is
278 blocked.
279  
280 This API guide is for developers who need detailed information about
281 WAF API actions, data types, and errors. For detailed information about
282 WAF features and an overview of how to use WAF, see the WAF Developer
283 Guide (https://docs.aws.amazon.com/waf/latest/developerguide/).
284  
285 You can make calls using the endpoints listed in Amazon Web Services
286 Service Endpoints for WAF
287 (https://docs.aws.amazon.com/general/latest/gr/rande.html#waf_region).
288  
289 =over
290  
291 =item *
292  
293 For regional applications, you can use any of the endpoints in the
294 list. A regional application can be an Application Load Balancer (ALB),
295 an Amazon API Gateway REST API, or an AppSync GraphQL API.
296  
297 =item *
298  
299 For Amazon CloudFront applications, you must use the API endpoint
300 listed for US East (N. Virginia): us-east-1.
301  
302 =back
303  
304 Alternatively, you can use one of the Amazon Web Services SDKs to
305 access an API that's tailored to the programming language or platform
306 that you're using. For more information, see Amazon Web Services SDKs
307 (http://aws.amazon.com/tools/#SDKs).
308  
309 We currently provide two versions of the WAF API: this API and the
310 prior versions, the classic WAF APIs. This new API provides the same
311 functionality as the older versions, with the following major
312 improvements:
313  
314 =over
315  
316 =item *
317  
318 You use one API for both global and regional applications. Where you
319 need to distinguish the scope, you specify a C<Scope> parameter and set
320 it to C<CLOUDFRONT> or C<REGIONAL>.
321  
322 =item *
323  
324 You can define a web ACL or rule group with a single call, and update
325 it with a single call. You define all rule specifications in JSON
326 format, and pass them to your rule group or web ACL calls.
327  
328 =item *
329  
330 The limits WAF places on the use of rules more closely reflects the
331 cost of running each type of rule. Rule groups include capacity
332 settings, so you know the maximum cost of a rule group when you use it.
333  
334 =back
335  
336  
337 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/wafv2-2019-07-29>
338  
339  
340 =head1 METHODS
341  
342 =head2 AssociateWebACL
343  
344 =over
345  
346 =item ResourceArn => Str
347  
348 =item WebACLArn => Str
349  
350  
351 =back
352  
353 Each argument is described in detail in: L<Paws::WAFV2::AssociateWebACL>
354  
355 Returns: a L<Paws::WAFV2::AssociateWebACLResponse> instance
356  
357 Associates a web ACL with a regional application resource, to protect
358 the resource. A regional application can be an Application Load
359 Balancer (ALB), an Amazon API Gateway REST API, or an AppSync GraphQL
360 API.
361  
362 For Amazon CloudFront, don't use this call. Instead, use your
363 CloudFront distribution configuration. To associate a web ACL, in the
364 CloudFront call C<UpdateDistribution>, set the web ACL ID to the Amazon
365 Resource Name (ARN) of the web ACL. For information, see
366 UpdateDistribution
367 (https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdateDistribution.html).
368  
369  
370 =head2 CheckCapacity
371  
372 =over
373  
374 =item Rules => ArrayRef[L<Paws::WAFV2::Rule>]
375  
376 =item Scope => Str
377  
378  
379 =back
380  
381 Each argument is described in detail in: L<Paws::WAFV2::CheckCapacity>
382  
383 Returns: a L<Paws::WAFV2::CheckCapacityResponse> instance
384  
385 Returns the web ACL capacity unit (WCU) requirements for a specified
386 scope and set of rules. You can use this to check the capacity
387 requirements for the rules you want to use in a RuleGroup or WebACL.
388  
389 WAF uses WCUs to calculate and control the operating resources that are
390 used to run your rules, rule groups, and web ACLs. WAF calculates
391 capacity differently for each rule type, to reflect the relative cost
392 of each rule. Simple rules that cost little to run use fewer WCUs than
393 more complex rules that use more processing power. Rule group capacity
394 is fixed at creation, which helps users plan their web ACL WCU usage
395 when they use a rule group. The WCU limit for web ACLs is 1,500.
396  
397  
398 =head2 CreateIPSet
399  
400 =over
401  
402 =item Addresses => ArrayRef[Str|Undef]
403  
404 =item IPAddressVersion => Str
405  
406 =item Name => Str
407  
408 =item Scope => Str
409  
410 =item [Description => Str]
411  
412 =item [Tags => ArrayRef[L<Paws::WAFV2::Tag>]]
413  
414  
415 =back
416  
417 Each argument is described in detail in: L<Paws::WAFV2::CreateIPSet>
418  
419 Returns: a L<Paws::WAFV2::CreateIPSetResponse> instance
420  
421 Creates an IPSet, which you use to identify web requests that originate
422 from specific IP addresses or ranges of IP addresses. For example, if
423 you're receiving a lot of requests from a ranges of IP addresses, you
424 can configure WAF to block them using an IPSet that lists those IP
425 addresses.
426  
427  
428 =head2 CreateRegexPatternSet
429  
430 =over
431  
432 =item Name => Str
433  
434 =item RegularExpressionList => ArrayRef[L<Paws::WAFV2::Regex>]
435  
436 =item Scope => Str
437  
438 =item [Description => Str]
439  
440 =item [Tags => ArrayRef[L<Paws::WAFV2::Tag>]]
441  
442  
443 =back
444  
445 Each argument is described in detail in: L<Paws::WAFV2::CreateRegexPatternSet>
446  
447 Returns: a L<Paws::WAFV2::CreateRegexPatternSetResponse> instance
448  
449 Creates a RegexPatternSet, which you reference in a
450 RegexPatternSetReferenceStatement, to have WAF inspect a web request
451 component for the specified patterns.
452  
453  
454 =head2 CreateRuleGroup
455  
456 =over
457  
458 =item Capacity => Int
459  
460 =item Name => Str
461  
462 =item Scope => Str
463  
464 =item VisibilityConfig => L<Paws::WAFV2::VisibilityConfig>
465  
466 =item [CustomResponseBodies => L<Paws::WAFV2::CustomResponseBodies>]
467  
468 =item [Description => Str]
469  
470 =item [Rules => ArrayRef[L<Paws::WAFV2::Rule>]]
471  
472 =item [Tags => ArrayRef[L<Paws::WAFV2::Tag>]]
473  
474  
475 =back
476  
477 Each argument is described in detail in: L<Paws::WAFV2::CreateRuleGroup>
478  
479 Returns: a L<Paws::WAFV2::CreateRuleGroupResponse> instance
480  
481 Creates a RuleGroup per the specifications provided.
482  
483 A rule group defines a collection of rules to inspect and control web
484 requests that you can use in a WebACL. When you create a rule group,
485 you define an immutable capacity limit. If you update a rule group, you
486 must stay within the capacity. This allows others to reuse the rule
487 group with confidence in its capacity requirements.
488  
489  
490 =head2 CreateWebACL
491  
492 =over
493  
494 =item DefaultAction => L<Paws::WAFV2::DefaultAction>
495  
496 =item Name => Str
497  
498 =item Scope => Str
499  
500 =item VisibilityConfig => L<Paws::WAFV2::VisibilityConfig>
501  
502 =item [CustomResponseBodies => L<Paws::WAFV2::CustomResponseBodies>]
503  
504 =item [Description => Str]
505  
506 =item [Rules => ArrayRef[L<Paws::WAFV2::Rule>]]
507  
508 =item [Tags => ArrayRef[L<Paws::WAFV2::Tag>]]
509  
510  
511 =back
512  
513 Each argument is described in detail in: L<Paws::WAFV2::CreateWebACL>
514  
515 Returns: a L<Paws::WAFV2::CreateWebACLResponse> instance
516  
517 Creates a WebACL per the specifications provided.
518  
519 A web ACL defines a collection of rules to use to inspect and control
520 web requests. Each rule has an action defined (allow, block, or count)
521 for requests that match the statement of the rule. In the web ACL, you
522 assign a default action to take (allow, block) for any request that
523 does not match any of the rules. The rules in a web ACL can be a
524 combination of the types Rule, RuleGroup, and managed rule group. You
525 can associate a web ACL with one or more Amazon Web Services resources
526 to protect. The resources can be an Amazon CloudFront distribution, an
527 Amazon API Gateway REST API, an Application Load Balancer, or an
528 AppSync GraphQL API.
529  
530  
531 =head2 DeleteFirewallManagerRuleGroups
532  
533 =over
534  
535 =item WebACLArn => Str
536  
537 =item WebACLLockToken => Str
538  
539  
540 =back
541  
542 Each argument is described in detail in: L<Paws::WAFV2::DeleteFirewallManagerRuleGroups>
543  
544 Returns: a L<Paws::WAFV2::DeleteFirewallManagerRuleGroupsResponse> instance
545  
546 Deletes all rule groups that are managed by Firewall Manager for the
547 specified web ACL.
548  
549 You can only use this if C<ManagedByFirewallManager> is false in the
550 specified WebACL.
551  
552  
553 =head2 DeleteIPSet
554  
555 =over
556  
557 =item Id => Str
558  
559 =item LockToken => Str
560  
561 =item Name => Str
562  
563 =item Scope => Str
564  
565  
566 =back
567  
568 Each argument is described in detail in: L<Paws::WAFV2::DeleteIPSet>
569  
570 Returns: a L<Paws::WAFV2::DeleteIPSetResponse> instance
571  
572 Deletes the specified IPSet.
573  
574  
575 =head2 DeleteLoggingConfiguration
576  
577 =over
578  
579 =item ResourceArn => Str
580  
581  
582 =back
583  
584 Each argument is described in detail in: L<Paws::WAFV2::DeleteLoggingConfiguration>
585  
586 Returns: a L<Paws::WAFV2::DeleteLoggingConfigurationResponse> instance
587  
588 Deletes the LoggingConfiguration from the specified web ACL.
589  
590  
591 =head2 DeletePermissionPolicy
592  
593 =over
594  
595 =item ResourceArn => Str
596  
597  
598 =back
599  
600 Each argument is described in detail in: L<Paws::WAFV2::DeletePermissionPolicy>
601  
602 Returns: a L<Paws::WAFV2::DeletePermissionPolicyResponse> instance
603  
604 Permanently deletes an IAM policy from the specified rule group.
605  
606 You must be the owner of the rule group to perform this operation.
607  
608  
609 =head2 DeleteRegexPatternSet
610  
611 =over
612  
613 =item Id => Str
614  
615 =item LockToken => Str
616  
617 =item Name => Str
618  
619 =item Scope => Str
620  
621  
622 =back
623  
624 Each argument is described in detail in: L<Paws::WAFV2::DeleteRegexPatternSet>
625  
626 Returns: a L<Paws::WAFV2::DeleteRegexPatternSetResponse> instance
627  
628 Deletes the specified RegexPatternSet.
629  
630  
631 =head2 DeleteRuleGroup
632  
633 =over
634  
635 =item Id => Str
636  
637 =item LockToken => Str
638  
639 =item Name => Str
640  
641 =item Scope => Str
642  
643  
644 =back
645  
646 Each argument is described in detail in: L<Paws::WAFV2::DeleteRuleGroup>
647  
648 Returns: a L<Paws::WAFV2::DeleteRuleGroupResponse> instance
649  
650 Deletes the specified RuleGroup.
651  
652  
653 =head2 DeleteWebACL
654  
655 =over
656  
657 =item Id => Str
658  
659 =item LockToken => Str
660  
661 =item Name => Str
662  
663 =item Scope => Str
664  
665  
666 =back
667  
668 Each argument is described in detail in: L<Paws::WAFV2::DeleteWebACL>
669  
670 Returns: a L<Paws::WAFV2::DeleteWebACLResponse> instance
671  
672 Deletes the specified WebACL.
673  
674 You can only use this if C<ManagedByFirewallManager> is false in the
675 specified WebACL.
676  
677  
678 =head2 DescribeManagedRuleGroup
679  
680 =over
681  
682 =item Name => Str
683  
684 =item Scope => Str
685  
686 =item VendorName => Str
687  
688  
689 =back
690  
691 Each argument is described in detail in: L<Paws::WAFV2::DescribeManagedRuleGroup>
692  
693 Returns: a L<Paws::WAFV2::DescribeManagedRuleGroupResponse> instance
694  
695 Provides high-level information for a managed rule group, including
696 descriptions of the rules.
697  
698  
699 =head2 DisassociateWebACL
700  
701 =over
702  
703 =item ResourceArn => Str
704  
705  
706 =back
707  
708 Each argument is described in detail in: L<Paws::WAFV2::DisassociateWebACL>
709  
710 Returns: a L<Paws::WAFV2::DisassociateWebACLResponse> instance
711  
712 Disassociates a web ACL from a regional application resource. A
713 regional application can be an Application Load Balancer (ALB), an
714 Amazon API Gateway REST API, or an AppSync GraphQL API.
715  
716 For Amazon CloudFront, don't use this call. Instead, use your
717 CloudFront distribution configuration. To disassociate a web ACL,
718 provide an empty web ACL ID in the CloudFront call
719 C<UpdateDistribution>. For information, see UpdateDistribution
720 (https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdateDistribution.html).
721  
722  
723 =head2 GetIPSet
724  
725 =over
726  
727 =item Id => Str
728  
729 =item Name => Str
730  
731 =item Scope => Str
732  
733  
734 =back
735  
736 Each argument is described in detail in: L<Paws::WAFV2::GetIPSet>
737  
738 Returns: a L<Paws::WAFV2::GetIPSetResponse> instance
739  
740 Retrieves the specified IPSet.
741  
742  
743 =head2 GetLoggingConfiguration
744  
745 =over
746  
747 =item ResourceArn => Str
748  
749  
750 =back
751  
752 Each argument is described in detail in: L<Paws::WAFV2::GetLoggingConfiguration>
753  
754 Returns: a L<Paws::WAFV2::GetLoggingConfigurationResponse> instance
755  
756 Returns the LoggingConfiguration for the specified web ACL.
757  
758  
759 =head2 GetPermissionPolicy
760  
761 =over
762  
763 =item ResourceArn => Str
764  
765  
766 =back
767  
768 Each argument is described in detail in: L<Paws::WAFV2::GetPermissionPolicy>
769  
770 Returns: a L<Paws::WAFV2::GetPermissionPolicyResponse> instance
771  
772 Returns the IAM policy that is attached to the specified rule group.
773  
774 You must be the owner of the rule group to perform this operation.
775  
776  
777 =head2 GetRateBasedStatementManagedKeys
778  
779 =over
780  
781 =item RuleName => Str
782  
783 =item Scope => Str
784  
785 =item WebACLId => Str
786  
787 =item WebACLName => Str
788  
789  
790 =back
791  
792 Each argument is described in detail in: L<Paws::WAFV2::GetRateBasedStatementManagedKeys>
793  
794 Returns: a L<Paws::WAFV2::GetRateBasedStatementManagedKeysResponse> instance
795  
796 Retrieves the keys that are currently blocked by a rate-based rule. The
797 maximum number of managed keys that can be blocked for a single
798 rate-based rule is 10,000. If more than 10,000 addresses exceed the
799 rate limit, those with the highest rates are blocked.
800  
801  
802 =head2 GetRegexPatternSet
803  
804 =over
805  
806 =item Id => Str
807  
808 =item Name => Str
809  
810 =item Scope => Str
811  
812  
813 =back
814  
815 Each argument is described in detail in: L<Paws::WAFV2::GetRegexPatternSet>
816  
817 Returns: a L<Paws::WAFV2::GetRegexPatternSetResponse> instance
818  
819 Retrieves the specified RegexPatternSet.
820  
821  
822 =head2 GetRuleGroup
823  
824 =over
825  
826 =item [ARN => Str]
827  
828 =item [Id => Str]
829  
830 =item [Name => Str]
831  
832 =item [Scope => Str]
833  
834  
835 =back
836  
837 Each argument is described in detail in: L<Paws::WAFV2::GetRuleGroup>
838  
839 Returns: a L<Paws::WAFV2::GetRuleGroupResponse> instance
840  
841 Retrieves the specified RuleGroup.
842  
843  
844 =head2 GetSampledRequests
845  
846 =over
847  
848 =item MaxItems => Int
849  
850 =item RuleMetricName => Str
851  
852 =item Scope => Str
853  
854 =item TimeWindow => L<Paws::WAFV2::TimeWindow>
855  
856 =item WebAclArn => Str
857  
858  
859 =back
860  
861 Each argument is described in detail in: L<Paws::WAFV2::GetSampledRequests>
862  
863 Returns: a L<Paws::WAFV2::GetSampledRequestsResponse> instance
864  
865 Gets detailed information about a specified number of requests--a
866 sample--that WAF randomly selects from among the first 5,000 requests
867 that your Amazon Web Services resource received during a time range
868 that you choose. You can specify a sample size of up to 500 requests,
869 and you can specify any time range in the previous three hours.
870  
871 C<GetSampledRequests> returns a time range, which is usually the time
872 range that you specified. However, if your resource (such as a
873 CloudFront distribution) received 5,000 requests before the specified
874 time range elapsed, C<GetSampledRequests> returns an updated time
875 range. This new time range indicates the actual period during which WAF
876 selected the requests in the sample.
877  
878  
879 =head2 GetWebACL
880  
881 =over
882  
883 =item Id => Str
884  
885 =item Name => Str
886  
887 =item Scope => Str
888  
889  
890 =back
891  
892 Each argument is described in detail in: L<Paws::WAFV2::GetWebACL>
893  
894 Returns: a L<Paws::WAFV2::GetWebACLResponse> instance
895  
896 Retrieves the specified WebACL.
897  
898  
899 =head2 GetWebACLForResource
900  
901 =over
902  
903 =item ResourceArn => Str
904  
905  
906 =back
907  
908 Each argument is described in detail in: L<Paws::WAFV2::GetWebACLForResource>
909  
910 Returns: a L<Paws::WAFV2::GetWebACLForResourceResponse> instance
911  
912 Retrieves the WebACL for the specified resource.
913  
914  
915 =head2 ListAvailableManagedRuleGroups
916  
917 =over
918  
919 =item Scope => Str
920  
921 =item [Limit => Int]
922  
923 =item [NextMarker => Str]
924  
925  
926 =back
927  
928 Each argument is described in detail in: L<Paws::WAFV2::ListAvailableManagedRuleGroups>
929  
930 Returns: a L<Paws::WAFV2::ListAvailableManagedRuleGroupsResponse> instance
931  
932 Retrieves an array of managed rule groups that are available for you to
933 use. This list includes all Amazon Web Services Managed Rules rule
934 groups and the Marketplace managed rule groups that you're subscribed
935 to.
936  
937  
938 =head2 ListIPSets
939  
940 =over
941  
942 =item Scope => Str
943  
944 =item [Limit => Int]
945  
946 =item [NextMarker => Str]
947  
948  
949 =back
950  
951 Each argument is described in detail in: L<Paws::WAFV2::ListIPSets>
952  
953 Returns: a L<Paws::WAFV2::ListIPSetsResponse> instance
954  
955 Retrieves an array of IPSetSummary objects for the IP sets that you
956 manage.
957  
958  
959 =head2 ListLoggingConfigurations
960  
961 =over
962  
963 =item [Limit => Int]
964  
965 =item [NextMarker => Str]
966  
967 =item [Scope => Str]
968  
969  
970 =back
971  
972 Each argument is described in detail in: L<Paws::WAFV2::ListLoggingConfigurations>
973  
974 Returns: a L<Paws::WAFV2::ListLoggingConfigurationsResponse> instance
975  
976 Retrieves an array of your LoggingConfiguration objects.
977  
978  
979 =head2 ListRegexPatternSets
980  
981 =over
982  
983 =item Scope => Str
984  
985 =item [Limit => Int]
986  
987 =item [NextMarker => Str]
988  
989  
990 =back
991  
992 Each argument is described in detail in: L<Paws::WAFV2::ListRegexPatternSets>
993  
994 Returns: a L<Paws::WAFV2::ListRegexPatternSetsResponse> instance
995  
996 Retrieves an array of RegexPatternSetSummary objects for the regex
997 pattern sets that you manage.
998  
999  
1000 =head2 ListResourcesForWebACL
1001  
1002 =over
1003  
1004 =item WebACLArn => Str
1005  
1006 =item [ResourceType => Str]
1007  
1008  
1009 =back
1010  
1011 Each argument is described in detail in: L<Paws::WAFV2::ListResourcesForWebACL>
1012  
1013 Returns: a L<Paws::WAFV2::ListResourcesForWebACLResponse> instance
1014  
1015 Retrieves an array of the Amazon Resource Names (ARNs) for the regional
1016 resources that are associated with the specified web ACL. If you want
1017 the list of Amazon CloudFront resources, use the CloudFront call
1018 C<ListDistributionsByWebACLId>.
1019  
1020  
1021 =head2 ListRuleGroups
1022  
1023 =over
1024  
1025 =item Scope => Str
1026  
1027 =item [Limit => Int]
1028  
1029 =item [NextMarker => Str]
1030  
1031  
1032 =back
1033  
1034 Each argument is described in detail in: L<Paws::WAFV2::ListRuleGroups>
1035  
1036 Returns: a L<Paws::WAFV2::ListRuleGroupsResponse> instance
1037  
1038 Retrieves an array of RuleGroupSummary objects for the rule groups that
1039 you manage.
1040  
1041  
1042 =head2 ListTagsForResource
1043  
1044 =over
1045  
1046 =item ResourceARN => Str
1047  
1048 =item [Limit => Int]
1049  
1050 =item [NextMarker => Str]
1051  
1052  
1053 =back
1054  
1055 Each argument is described in detail in: L<Paws::WAFV2::ListTagsForResource>
1056  
1057 Returns: a L<Paws::WAFV2::ListTagsForResourceResponse> instance
1058  
1059 Retrieves the TagInfoForResource for the specified resource. Tags are
1060 key:value pairs that you can use to categorize and manage your
1061 resources, for purposes like billing. For example, you might set the
1062 tag key to "customer" and the value to the customer name or ID. You can
1063 specify one or more tags to add to each Amazon Web Services resource,
1064 up to 50 tags for a resource.
1065  
1066 You can tag the Amazon Web Services resources that you manage through
1067 WAF: web ACLs, rule groups, IP sets, and regex pattern sets. You can't
1068 manage or view tags through the WAF console.
1069  
1070  
1071 =head2 ListWebACLs
1072  
1073 =over
1074  
1075 =item Scope => Str
1076  
1077 =item [Limit => Int]
1078  
1079 =item [NextMarker => Str]
1080  
1081  
1082 =back
1083  
1084 Each argument is described in detail in: L<Paws::WAFV2::ListWebACLs>
1085  
1086 Returns: a L<Paws::WAFV2::ListWebACLsResponse> instance
1087  
1088 Retrieves an array of WebACLSummary objects for the web ACLs that you
1089 manage.
1090  
1091  
1092 =head2 PutLoggingConfiguration
1093  
1094 =over
1095  
1096 =item LoggingConfiguration => L<Paws::WAFV2::LoggingConfiguration>
1097  
1098  
1099 =back
1100  
1101 Each argument is described in detail in: L<Paws::WAFV2::PutLoggingConfiguration>
1102  
1103 Returns: a L<Paws::WAFV2::PutLoggingConfigurationResponse> instance
1104  
1105 Enables the specified LoggingConfiguration, to start logging from a web
1106 ACL, according to the configuration provided.
1107  
1108 You can access information about all traffic that WAF inspects using
1109 the following steps:
1110  
1111 =over
1112  
1113 =item 1.
1114  
1115 Create an Amazon Kinesis Data Firehose.
1116  
1117 Create the data firehose with a PUT source and in the Region that you
1118 are operating. If you are capturing logs for Amazon CloudFront, always
1119 create the firehose in US East (N. Virginia).
1120  
1121 Give the data firehose a name that starts with the prefix
1122 C<aws-waf-logs->. For example, C<aws-waf-logs-us-east-2-analytics>.
1123  
1124 Do not create the data firehose using a C<Kinesis stream> as your
1125 source.
1126  
1127 =item 2.
1128  
1129 Associate that firehose to your web ACL using a
1130 C<PutLoggingConfiguration> request.
1131  
1132 =back
1133  
1134 When you successfully enable logging using a C<PutLoggingConfiguration>
1135 request, WAF will create a service linked role with the necessary
1136 permissions to write logs to the Amazon Kinesis Data Firehose. For more
1137 information, see Logging Web ACL Traffic Information
1138 (https://docs.aws.amazon.com/waf/latest/developerguide/logging.html) in
1139 the I<WAF Developer Guide>.
1140  
1141 This operation completely replaces the mutable specifications that you
1142 already have for the logging configuration with the ones that you
1143 provide to this call. To modify the logging configuration, retrieve it
1144 by calling GetLoggingConfiguration, update the settings as needed, and
1145 then provide the complete logging configuration specification to this
1146 call.
1147  
1148  
1149 =head2 PutPermissionPolicy
1150  
1151 =over
1152  
1153 =item Policy => Str
1154  
1155 =item ResourceArn => Str
1156  
1157  
1158 =back
1159  
1160 Each argument is described in detail in: L<Paws::WAFV2::PutPermissionPolicy>
1161  
1162 Returns: a L<Paws::WAFV2::PutPermissionPolicyResponse> instance
1163  
1164 Attaches an IAM policy to the specified resource. Use this to share a
1165 rule group across accounts.
1166  
1167 You must be the owner of the rule group to perform this operation.
1168  
1169 This action is subject to the following restrictions:
1170  
1171 =over
1172  
1173 =item *
1174  
1175 You can attach only one policy with each C<PutPermissionPolicy>
1176 request.
1177  
1178 =item *
1179  
1180 The ARN in the request must be a valid WAF RuleGroup ARN and the rule
1181 group must exist in the same Region.
1182  
1183 =item *
1184  
1185 The user making the request must be the owner of the rule group.
1186  
1187 =back
1188  
1189  
1190  
1191 =head2 TagResource
1192  
1193 =over
1194  
1195 =item ResourceARN => Str
1196  
1197 =item Tags => ArrayRef[L<Paws::WAFV2::Tag>]
1198  
1199  
1200 =back
1201  
1202 Each argument is described in detail in: L<Paws::WAFV2::TagResource>
1203  
1204 Returns: a L<Paws::WAFV2::TagResourceResponse> instance
1205  
1206 Associates tags with the specified Amazon Web Services resource. Tags
1207 are key:value pairs that you can use to categorize and manage your
1208 resources, for purposes like billing. For example, you might set the
1209 tag key to "customer" and the value to the customer name or ID. You can
1210 specify one or more tags to add to each Amazon Web Services resource,
1211 up to 50 tags for a resource.
1212  
1213 You can tag the Amazon Web Services resources that you manage through
1214 WAF: web ACLs, rule groups, IP sets, and regex pattern sets. You can't
1215 manage or view tags through the WAF console.
1216  
1217  
1218 =head2 UntagResource
1219  
1220 =over
1221  
1222 =item ResourceARN => Str
1223  
1224 =item TagKeys => ArrayRef[Str|Undef]
1225  
1226  
1227 =back
1228  
1229 Each argument is described in detail in: L<Paws::WAFV2::UntagResource>
1230  
1231 Returns: a L<Paws::WAFV2::UntagResourceResponse> instance
1232  
1233 Disassociates tags from an Amazon Web Services resource. Tags are
1234 key:value pairs that you can associate with Amazon Web Services
1235 resources. For example, the tag key might be "customer" and the tag
1236 value might be "companyA." You can specify one or more tags to add to
1237 each container. You can add up to 50 tags to each Amazon Web Services
1238 resource.
1239  
1240  
1241 =head2 UpdateIPSet
1242  
1243 =over
1244  
1245 =item Addresses => ArrayRef[Str|Undef]
1246  
1247 =item Id => Str
1248  
1249 =item LockToken => Str
1250  
1251 =item Name => Str
1252  
1253 =item Scope => Str
1254  
1255 =item [Description => Str]
1256  
1257  
1258 =back
1259  
1260 Each argument is described in detail in: L<Paws::WAFV2::UpdateIPSet>
1261  
1262 Returns: a L<Paws::WAFV2::UpdateIPSetResponse> instance
1263  
1264 Updates the specified IPSet.
1265  
1266 This operation completely replaces the mutable specifications that you
1267 already have for the IP set with the ones that you provide to this
1268 call. To modify the IP set, retrieve it by calling GetIPSet, update the
1269 settings as needed, and then provide the complete IP set specification
1270 to this call.
1271  
1272  
1273 =head2 UpdateRegexPatternSet
1274  
1275 =over
1276  
1277 =item Id => Str
1278  
1279 =item LockToken => Str
1280  
1281 =item Name => Str
1282  
1283 =item RegularExpressionList => ArrayRef[L<Paws::WAFV2::Regex>]
1284  
1285 =item Scope => Str
1286  
1287 =item [Description => Str]
1288  
1289  
1290 =back
1291  
1292 Each argument is described in detail in: L<Paws::WAFV2::UpdateRegexPatternSet>
1293  
1294 Returns: a L<Paws::WAFV2::UpdateRegexPatternSetResponse> instance
1295  
1296 Updates the specified RegexPatternSet.
1297  
1298 This operation completely replaces the mutable specifications that you
1299 already have for the regex pattern set with the ones that you provide
1300 to this call. To modify the regex pattern set, retrieve it by calling
1301 GetRegexPatternSet, update the settings as needed, and then provide the
1302 complete regex pattern set specification to this call.
1303  
1304  
1305 =head2 UpdateRuleGroup
1306  
1307 =over
1308  
1309 =item Id => Str
1310  
1311 =item LockToken => Str
1312  
1313 =item Name => Str
1314  
1315 =item Scope => Str
1316  
1317 =item VisibilityConfig => L<Paws::WAFV2::VisibilityConfig>
1318  
1319 =item [CustomResponseBodies => L<Paws::WAFV2::CustomResponseBodies>]
1320  
1321 =item [Description => Str]
1322  
1323 =item [Rules => ArrayRef[L<Paws::WAFV2::Rule>]]
1324  
1325  
1326 =back
1327  
1328 Each argument is described in detail in: L<Paws::WAFV2::UpdateRuleGroup>
1329  
1330 Returns: a L<Paws::WAFV2::UpdateRuleGroupResponse> instance
1331  
1332 Updates the specified RuleGroup.
1333  
1334 This operation completely replaces the mutable specifications that you
1335 already have for the rule group with the ones that you provide to this
1336 call. To modify the rule group, retrieve it by calling GetRuleGroup,
1337 update the settings as needed, and then provide the complete rule group
1338 specification to this call.
1339  
1340 A rule group defines a collection of rules to inspect and control web
1341 requests that you can use in a WebACL. When you create a rule group,
1342 you define an immutable capacity limit. If you update a rule group, you
1343 must stay within the capacity. This allows others to reuse the rule
1344 group with confidence in its capacity requirements.
1345  
1346  
1347 =head2 UpdateWebACL
1348  
1349 =over
1350  
1351 =item DefaultAction => L<Paws::WAFV2::DefaultAction>
1352  
1353 =item Id => Str
1354  
1355 =item LockToken => Str
1356  
1357 =item Name => Str
1358  
1359 =item Scope => Str
1360  
1361 =item VisibilityConfig => L<Paws::WAFV2::VisibilityConfig>
1362  
1363 =item [CustomResponseBodies => L<Paws::WAFV2::CustomResponseBodies>]
1364  
1365 =item [Description => Str]
1366  
1367 =item [Rules => ArrayRef[L<Paws::WAFV2::Rule>]]
1368  
1369  
1370 =back
1371  
1372 Each argument is described in detail in: L<Paws::WAFV2::UpdateWebACL>
1373  
1374 Returns: a L<Paws::WAFV2::UpdateWebACLResponse> instance
1375  
1376 Updates the specified WebACL.
1377  
1378 This operation completely replaces the mutable specifications that you
1379 already have for the web ACL with the ones that you provide to this
1380 call. To modify the web ACL, retrieve it by calling GetWebACL, update
1381 the settings as needed, and then provide the complete web ACL
1382 specification to this call.
1383  
1384 A web ACL defines a collection of rules to use to inspect and control
1385 web requests. Each rule has an action defined (allow, block, or count)
1386 for requests that match the statement of the rule. In the web ACL, you
1387 assign a default action to take (allow, block) for any request that
1388 does not match any of the rules. The rules in a web ACL can be a
1389 combination of the types Rule, RuleGroup, and managed rule group. You
1390 can associate a web ACL with one or more Amazon Web Services resources
1391 to protect. The resources can be an Amazon CloudFront distribution, an
1392 Amazon API Gateway REST API, an Application Load Balancer, or an
1393 AppSync GraphQL API.
1394  
1395  
1396  
1397  
1398 =head1 PAGINATORS
1399  
1400 Paginator methods are helpers that repetively call methods that return partial results
1401  
1402  
1403  
1404  
1405 =head1 SEE ALSO
1406  
1407 This service class forms part of L<Paws>
1408  
1409 =head1 BUGS and CONTRIBUTIONS
1410  
1411 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
1412  
1413 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
1414  
1415 =cut
1416