getRulesPackages function
Future<GetRulesPackagesResult>
getRulesPackages(
- GetRulesPackagesArgs args, {
- InvokeOptions? options,
The Amazon Inspector Classic Rules Packages data source allows access to the list of AWS Inspector Rules Packages which can be used by Amazon Inspector Classic within the region configured in the provider.
Example Usage
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
// Declare the data source
const rules = aws.inspector.getRulesPackages({});
// e.g., Use in aws_inspector_assessment_template
const group = new aws.inspector.ResourceGroup("group", {tags: {
test: "test",
}});
const assessment = new aws.inspector.AssessmentTarget("assessment", {
name: "test",
resourceGroupArn: group.arn,
});
const assessmentAssessmentTemplate = new aws.inspector.AssessmentTemplate("assessment", {
name: "Test",
targetArn: assessment.arn,
duration: 60,
rulesPackageArns: rules.then(rules => rules.arns),
});
import pulumi
import pulumi_aws as aws
# Declare the data source
rules = aws.inspector.get_rules_packages()
# e.g., Use in aws_inspector_assessment_template
group = aws.inspector.ResourceGroup("group", tags={
"test": "test",
})
assessment = aws.inspector.AssessmentTarget("assessment",
name="test",
resource_group_arn=group.arn)
assessment_assessment_template = aws.inspector.AssessmentTemplate("assessment",
name="Test",
target_arn=assessment.arn,
duration=60,
rules_package_arns=rules.arns)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
// Declare the data source
var rules = Aws.Inspector.GetRulesPackages.Invoke();
// e.g., Use in aws_inspector_assessment_template
var @group = new Aws.Inspector.ResourceGroup("group", new()
{
Tags =
{
{ "test", "test" },
},
});
var assessment = new Aws.Inspector.AssessmentTarget("assessment", new()
{
Name = "test",
ResourceGroupArn = @group.Arn,
});
var assessmentAssessmentTemplate = new Aws.Inspector.AssessmentTemplate("assessment", new()
{
Name = "Test",
TargetArn = assessment.Arn,
Duration = 60,
RulesPackageArns = rules.Apply(getRulesPackagesResult => getRulesPackagesResult.Arns),
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/inspector"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
// Declare the data source
rules, err := inspector.GetRulesPackages(ctx, &inspector.GetRulesPackagesArgs{}, nil)
if err != nil {
return err
}
// e.g., Use in aws_inspector_assessment_template
group, err := inspector.NewResourceGroup(ctx, "group", &inspector.ResourceGroupArgs{
Tags: pulumi.StringMap{
"test": pulumi.String("test"),
},
})
if err != nil {
return err
}
assessment, err := inspector.NewAssessmentTarget(ctx, "assessment", &inspector.AssessmentTargetArgs{
Name: pulumi.String("test"),
ResourceGroupArn: group.Arn,
})
if err != nil {
return err
}
_, err = inspector.NewAssessmentTemplate(ctx, "assessment", &inspector.AssessmentTemplateArgs{
Name: pulumi.String("Test"),
TargetArn: assessment.Arn,
Duration: pulumi.Int(60),
RulesPackageArns: toPulumiStringArray(rules.Arns),
})
if err != nil {
return err
}
return nil
})
}
func toPulumiStringArray(arr []string) pulumi.StringArray {
var pulumiArr pulumi.StringArray
for _, v := range arr {
pulumiArr = append(pulumiArr, pulumi.String(v))
}
return pulumiArr
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
data "aws_inspector_getrulespackages" "rules" {
}
# e.g., Use in aws_inspector_assessment_template
resource "aws_inspector_resourcegroup" "group" {
tags = {
"test" = "test"
}
}
resource "aws_inspector_assessmenttarget" "assessment" {
name = "test"
resource_group_arn = aws_inspector_resourcegroup.group.arn
}
resource "aws_inspector_assessmenttemplate" "assessment" {
name = "Test"
target_arn = aws_inspector_assessmenttarget.assessment.arn
duration = "60"
rules_package_arns = data.aws_inspector_getrulespackages.rules.arns
}
# Declare the data source
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.inspector.InspectorFunctions;
import com.pulumi.aws.inspector.inputs.GetRulesPackagesArgs;
import com.pulumi.aws.inspector.ResourceGroup;
import com.pulumi.aws.inspector.ResourceGroupArgs;
import com.pulumi.aws.inspector.AssessmentTarget;
import com.pulumi.aws.inspector.AssessmentTargetArgs;
import com.pulumi.aws.inspector.AssessmentTemplate;
import com.pulumi.aws.inspector.AssessmentTemplateArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
// Declare the data source
final var rules = InspectorFunctions.getRulesPackages(GetRulesPackagesArgs.builder()
.build());
// e.g., Use in aws_inspector_assessment_template
var group = new ResourceGroup("group", ResourceGroupArgs.builder()
.tags(Map.of("test", "test"))
.build());
var assessment = new AssessmentTarget("assessment", AssessmentTargetArgs.builder()
.name("test")
.resourceGroupArn(group.arn())
.build());
var assessmentAssessmentTemplate = new AssessmentTemplate("assessmentAssessmentTemplate", AssessmentTemplateArgs.builder()
.name("Test")
.targetArn(assessment.arn())
.duration(60)
.rulesPackageArns(rules.arns())
.build());
}
}
resources:
# e.g., Use in aws_inspector_assessment_template
group:
type: aws:inspector:ResourceGroup
properties:
tags:
test: test
assessment:
type: aws:inspector:AssessmentTarget
properties:
name: test
resourceGroupArn: ${group.arn}
assessmentAssessmentTemplate:
type: aws:inspector:AssessmentTemplate
name: assessment
properties:
name: Test
targetArn: ${assessment.arn}
duration: '60'
rulesPackageArns: ${rules.arns}
variables:
# Declare the data source
rules:
fn::invoke:
function: aws:inspector:getRulesPackages
arguments: {}
args Arguments passed to this invoke. Arguments for getRulesPackages.
options Invoke options controlling this call.
Implementation
Future<GetRulesPackagesResult> getRulesPackages(
GetRulesPackagesArgs args, {
pulumi.InvokeOptions? options,
}) async {
final deployment = pulumi.Deployment.instance;
final result = await deployment.invoke<Map<String, dynamic>>(
'aws:inspector/getRulesPackages:getRulesPackages',
args.toMap(),
options: pulumi.toDeploymentInvokeOptions(options),
);
return GetRulesPackagesResult.fromMap(result);
}