Analyzer class

Manages an Access Analyzer Analyzer. More information can be found in the Access Analyzer User Guide.

Example Usage

Account Analyzer

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.accessanalyzer.Analyzer("example", {analyzerName: "example"});
import pulumi
import pulumi_aws as aws

example = aws.accessanalyzer.Analyzer("example", analyzer_name="example")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.AccessAnalyzer.Analyzer("example", new()
    {
        AnalyzerName = "example",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/accessanalyzer"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := accessanalyzer.NewAnalyzer(ctx, "example", &accessanalyzer.AnalyzerArgs{
			AnalyzerName: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_accessanalyzer_analyzer" "example" {
  analyzer_name = "example"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.accessanalyzer.Analyzer;
import com.pulumi.aws.accessanalyzer.AnalyzerArgs;
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) {
        var example = new Analyzer("example", AnalyzerArgs.builder()
            .analyzerName("example")
            .build());

    }
}
resources:
  example:
    type: aws:accessanalyzer:Analyzer
    properties:
      analyzerName: example

Organization Analyzer

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.organizations.Organization("example", {awsServiceAccessPrincipals: ["access-analyzer.amazonaws.com"]});
const exampleAnalyzer = new aws.accessanalyzer.Analyzer("example", {
    analyzerName: "example",
    type: "ORGANIZATION",
}, {
    dependsOn: [example],
});
import pulumi
import pulumi_aws as aws

example = aws.organizations.Organization("example", aws_service_access_principals=["access-analyzer.amazonaws.com"])
example_analyzer = aws.accessanalyzer.Analyzer("example",
    analyzer_name="example",
    type="ORGANIZATION",
    opts = pulumi.ResourceOptions(depends_on=[example]))
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Organizations.Organization("example", new()
    {
        AwsServiceAccessPrincipals = new[]
        {
            "access-analyzer.amazonaws.com",
        },
    });

    var exampleAnalyzer = new Aws.AccessAnalyzer.Analyzer("example", new()
    {
        AnalyzerName = "example",
        Type = "ORGANIZATION",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            example,
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/accessanalyzer"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/organizations"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := organizations.NewOrganization(ctx, "example", &organizations.OrganizationArgs{
			AwsServiceAccessPrincipals: pulumi.StringArray{
				pulumi.String("access-analyzer.amazonaws.com"),
			},
		})
		if err != nil {
			return err
		}
		_, err = accessanalyzer.NewAnalyzer(ctx, "example", &accessanalyzer.AnalyzerArgs{
			AnalyzerName: pulumi.String("example"),
			Type:         pulumi.String("ORGANIZATION"),
		}, pulumi.DependsOn([]pulumi.Resource{
			example,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_organizations_organization" "example" {
  aws_service_access_principals = ["access-analyzer.amazonaws.com"]
}
resource "aws_accessanalyzer_analyzer" "example" {
  depends_on    = [aws_organizations_organization.example]
  analyzer_name = "example"
  type          = "ORGANIZATION"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.organizations.Organization;
import com.pulumi.aws.organizations.OrganizationArgs;
import com.pulumi.aws.accessanalyzer.Analyzer;
import com.pulumi.aws.accessanalyzer.AnalyzerArgs;
import com.pulumi.resources.CustomResourceOptions;
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) {
        var example = new Organization("example", OrganizationArgs.builder()
            .awsServiceAccessPrincipals("access-analyzer.amazonaws.com")
            .build());

        var exampleAnalyzer = new Analyzer("exampleAnalyzer", AnalyzerArgs.builder()
            .analyzerName("example")
            .type("ORGANIZATION")
            .build(), CustomResourceOptions.builder()
                .dependsOn(example)
                .build());

    }
}
resources:
  example:
    type: aws:organizations:Organization
    properties:
      awsServiceAccessPrincipals:
        - access-analyzer.amazonaws.com
  exampleAnalyzer:
    type: aws:accessanalyzer:Analyzer
    name: example
    properties:
      analyzerName: example
      type: ORGANIZATION
    options:
      dependsOn:
        - ${example}

Organization Unused Access Analyzer With Analysis Rule

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.accessanalyzer.Analyzer("example", {
    configuration: {
        unusedAccess: {
            analysisRule: {
                exclusions: [
                    {
                        accountIds: [
                            "123456789012",
                            "234567890123",
                        ],
                    },
                    {
                        resourceTags: [
                            {
                                key1: "value1",
                            },
                            {
                                key2: "value2",
                            },
                        ],
                    },
                ],
            },
            unusedAccessAge: 180,
        },
    },
    analyzerName: "example",
    type: "ORGANIZATION_UNUSED_ACCESS",
});
import pulumi
import pulumi_aws as aws

example = aws.accessanalyzer.Analyzer("example",
    configuration={
        "unused_access": {
            "analysis_rule": {
                "exclusions": [
                    {
                        "account_ids": [
                            "123456789012",
                            "234567890123",
                        ],
                    },
                    {
                        "resource_tags": [
                            {
                                "key1": "value1",
                            },
                            {
                                "key2": "value2",
                            },
                        ],
                    },
                ],
            },
            "unused_access_age": 180,
        },
    },
    analyzer_name="example",
    type="ORGANIZATION_UNUSED_ACCESS")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.AccessAnalyzer.Analyzer("example", new()
    {
        Configuration = new Aws.AccessAnalyzer.Inputs.AnalyzerConfigurationArgs
        {
            UnusedAccess = new Aws.AccessAnalyzer.Inputs.AnalyzerConfigurationUnusedAccessArgs
            {
                AnalysisRule = new Aws.AccessAnalyzer.Inputs.AnalyzerConfigurationUnusedAccessAnalysisRuleArgs
                {
                    Exclusions = new[]
                    {
                        new Aws.AccessAnalyzer.Inputs.AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs
                        {
                            AccountIds = new[]
                            {
                                "123456789012",
                                "234567890123",
                            },
                        },
                        new Aws.AccessAnalyzer.Inputs.AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs
                        {
                            ResourceTags = new[]
                            {

                                {
                                    { "key1", "value1" },
                                },

                                {
                                    { "key2", "value2" },
                                },
                            },
                        },
                    },
                },
                UnusedAccessAge = 180,
            },
        },
        AnalyzerName = "example",
        Type = "ORGANIZATION_UNUSED_ACCESS",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/accessanalyzer"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := accessanalyzer.NewAnalyzer(ctx, "example", &accessanalyzer.AnalyzerArgs{
			Configuration: &accessanalyzer.AnalyzerConfigurationArgs{
				UnusedAccess: &accessanalyzer.AnalyzerConfigurationUnusedAccessArgs{
					AnalysisRule: &accessanalyzer.AnalyzerConfigurationUnusedAccessAnalysisRuleArgs{
						Exclusions: accessanalyzer.AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArray{
							&accessanalyzer.AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs{
								AccountIds: pulumi.StringArray{
									pulumi.String("123456789012"),
									pulumi.String("234567890123"),
								},
							},
							&accessanalyzer.AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs{
								ResourceTags: pulumi.StringMapArray{
									pulumi.StringMap{
										"key1": pulumi.String("value1"),
									},
									pulumi.StringMap{
										"key2": pulumi.String("value2"),
									},
								},
							},
						},
					},
					UnusedAccessAge: pulumi.Int(180),
				},
			},
			AnalyzerName: pulumi.String("example"),
			Type:         pulumi.String("ORGANIZATION_UNUSED_ACCESS"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_accessanalyzer_analyzer" "example" {
  configuration = {
    unused_access = {
      analysis_rule = {
        exclusions = [{
          "accountIds" = ["123456789012", "234567890123"]
          }, {
          "resourceTags" = [{
            "key1" = "value1"
            }, {
            "key2" = "value2"
          }]
        }]
      }
      unused_access_age = 180
    }
  }
  analyzer_name = "example"
  type          = "ORGANIZATION_UNUSED_ACCESS"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.accessanalyzer.Analyzer;
import com.pulumi.aws.accessanalyzer.AnalyzerArgs;
import com.pulumi.aws.accessanalyzer.inputs.AnalyzerConfigurationArgs;
import com.pulumi.aws.accessanalyzer.inputs.AnalyzerConfigurationUnusedAccessArgs;
import com.pulumi.aws.accessanalyzer.inputs.AnalyzerConfigurationUnusedAccessAnalysisRuleArgs;
import com.pulumi.aws.accessanalyzer.inputs.AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs;
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) {
        var example = new Analyzer("example", AnalyzerArgs.builder()
            .configuration(AnalyzerConfigurationArgs.builder()
                .unusedAccess(AnalyzerConfigurationUnusedAccessArgs.builder()
                    .analysisRule(AnalyzerConfigurationUnusedAccessAnalysisRuleArgs.builder()
                        .exclusions(
                            AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs.builder()
                                .accountIds(
                                    "123456789012",
                                    "234567890123")
                                .build(),
                            AnalyzerConfigurationUnusedAccessAnalysisRuleExclusionArgs.builder()
                                .resourceTags(
                                    Map.of("key1", "value1"),
                                    Map.of("key2", "value2"))
                                .build())
                        .build())
                    .unusedAccessAge(180)
                    .build())
                .build())
            .analyzerName("example")
            .type("ORGANIZATION_UNUSED_ACCESS")
            .build());

    }
}
resources:
  example:
    type: aws:accessanalyzer:Analyzer
    properties:
      configuration:
        unusedAccess:
          analysisRule:
            exclusions:
              - accountIds:
                  - '123456789012'
                  - '234567890123'
              - resourceTags:
                  - key1: value1
                  - key2: value2
          unusedAccessAge: 180
      analyzerName: example
      type: ORGANIZATION_UNUSED_ACCESS

Account Internal Access Analyzer by Resource Types

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const test = new aws.accessanalyzer.Analyzer("test", {
    configuration: {
        internalAccess: {
            analysisRule: {
                inclusions: [{
                    resourceTypes: [
                        "AWS::S3::Bucket",
                        "AWS::RDS::DBSnapshot",
                        "AWS::DynamoDB::Table",
                    ],
                }],
            },
        },
    },
    analyzerName: "example",
    type: "ORGANIZATION_INTERNAL_ACCESS",
});
import pulumi
import pulumi_aws as aws

test = aws.accessanalyzer.Analyzer("test",
    configuration={
        "internal_access": {
            "analysis_rule": {
                "inclusions": [{
                    "resource_types": [
                        "AWS::S3::Bucket",
                        "AWS::RDS::DBSnapshot",
                        "AWS::DynamoDB::Table",
                    ],
                }],
            },
        },
    },
    analyzer_name="example",
    type="ORGANIZATION_INTERNAL_ACCESS")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var test = new Aws.AccessAnalyzer.Analyzer("test", new()
    {
        Configuration = new Aws.AccessAnalyzer.Inputs.AnalyzerConfigurationArgs
        {
            InternalAccess = new Aws.AccessAnalyzer.Inputs.AnalyzerConfigurationInternalAccessArgs
            {
                AnalysisRule = new Aws.AccessAnalyzer.Inputs.AnalyzerConfigurationInternalAccessAnalysisRuleArgs
                {
                    Inclusions = new[]
                    {
                        new Aws.AccessAnalyzer.Inputs.AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs
                        {
                            ResourceTypes = new[]
                            {
                                "AWS::S3::Bucket",
                                "AWS::RDS::DBSnapshot",
                                "AWS::DynamoDB::Table",
                            },
                        },
                    },
                },
            },
        },
        AnalyzerName = "example",
        Type = "ORGANIZATION_INTERNAL_ACCESS",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/accessanalyzer"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := accessanalyzer.NewAnalyzer(ctx, "test", &accessanalyzer.AnalyzerArgs{
			Configuration: &accessanalyzer.AnalyzerConfigurationArgs{
				InternalAccess: &accessanalyzer.AnalyzerConfigurationInternalAccessArgs{
					AnalysisRule: &accessanalyzer.AnalyzerConfigurationInternalAccessAnalysisRuleArgs{
						Inclusions: accessanalyzer.AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArray{
							&accessanalyzer.AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs{
								ResourceTypes: pulumi.StringArray{
									pulumi.String("AWS::S3::Bucket"),
									pulumi.String("AWS::RDS::DBSnapshot"),
									pulumi.String("AWS::DynamoDB::Table"),
								},
							},
						},
					},
				},
			},
			AnalyzerName: pulumi.String("example"),
			Type:         pulumi.String("ORGANIZATION_INTERNAL_ACCESS"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_accessanalyzer_analyzer" "test" {
  configuration = {
    internal_access = {
      analysis_rule = {
        inclusions = [{
          "resourceTypes" = ["AWS::S3::Bucket", "AWS::RDS::DBSnapshot", "AWS::DynamoDB::Table"]
        }]
      }
    }
  }
  analyzer_name = "example"
  type          = "ORGANIZATION_INTERNAL_ACCESS"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.accessanalyzer.Analyzer;
import com.pulumi.aws.accessanalyzer.AnalyzerArgs;
import com.pulumi.aws.accessanalyzer.inputs.AnalyzerConfigurationArgs;
import com.pulumi.aws.accessanalyzer.inputs.AnalyzerConfigurationInternalAccessArgs;
import com.pulumi.aws.accessanalyzer.inputs.AnalyzerConfigurationInternalAccessAnalysisRuleArgs;
import com.pulumi.aws.accessanalyzer.inputs.AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs;
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) {
        var test = new Analyzer("test", AnalyzerArgs.builder()
            .configuration(AnalyzerConfigurationArgs.builder()
                .internalAccess(AnalyzerConfigurationInternalAccessArgs.builder()
                    .analysisRule(AnalyzerConfigurationInternalAccessAnalysisRuleArgs.builder()
                        .inclusions(AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs.builder()
                            .resourceTypes(
                                "AWS::S3::Bucket",
                                "AWS::RDS::DBSnapshot",
                                "AWS::DynamoDB::Table")
                            .build())
                        .build())
                    .build())
                .build())
            .analyzerName("example")
            .type("ORGANIZATION_INTERNAL_ACCESS")
            .build());

    }
}
resources:
  test:
    type: aws:accessanalyzer:Analyzer
    properties:
      configuration:
        internalAccess:
          analysisRule:
            inclusions:
              - resourceTypes:
                  - AWS::S3::Bucket
                  - AWS::RDS::DBSnapshot
                  - AWS::DynamoDB::Table
      analyzerName: example
      type: ORGANIZATION_INTERNAL_ACCESS

Organization Internal Access Analyzer by Account ID and Resource ARN

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const test = new aws.accessanalyzer.Analyzer("test", {
    configuration: {
        internalAccess: {
            analysisRule: {
                inclusions: [{
                    accountIds: ["123456789012"],
                    resourceArns: ["arn:aws:s3:::my-example-bucket"],
                }],
            },
        },
    },
    analyzerName: "example",
    type: "ORGANIZATION_INTERNAL_ACCESS",
});
import pulumi
import pulumi_aws as aws

test = aws.accessanalyzer.Analyzer("test",
    configuration={
        "internal_access": {
            "analysis_rule": {
                "inclusions": [{
                    "account_ids": ["123456789012"],
                    "resource_arns": ["arn:aws:s3:::my-example-bucket"],
                }],
            },
        },
    },
    analyzer_name="example",
    type="ORGANIZATION_INTERNAL_ACCESS")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var test = new Aws.AccessAnalyzer.Analyzer("test", new()
    {
        Configuration = new Aws.AccessAnalyzer.Inputs.AnalyzerConfigurationArgs
        {
            InternalAccess = new Aws.AccessAnalyzer.Inputs.AnalyzerConfigurationInternalAccessArgs
            {
                AnalysisRule = new Aws.AccessAnalyzer.Inputs.AnalyzerConfigurationInternalAccessAnalysisRuleArgs
                {
                    Inclusions = new[]
                    {
                        new Aws.AccessAnalyzer.Inputs.AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs
                        {
                            AccountIds = new[]
                            {
                                "123456789012",
                            },
                            ResourceArns = new[]
                            {
                                "arn:aws:s3:::my-example-bucket",
                            },
                        },
                    },
                },
            },
        },
        AnalyzerName = "example",
        Type = "ORGANIZATION_INTERNAL_ACCESS",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/accessanalyzer"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := accessanalyzer.NewAnalyzer(ctx, "test", &accessanalyzer.AnalyzerArgs{
			Configuration: &accessanalyzer.AnalyzerConfigurationArgs{
				InternalAccess: &accessanalyzer.AnalyzerConfigurationInternalAccessArgs{
					AnalysisRule: &accessanalyzer.AnalyzerConfigurationInternalAccessAnalysisRuleArgs{
						Inclusions: accessanalyzer.AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArray{
							&accessanalyzer.AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs{
								AccountIds: pulumi.StringArray{
									pulumi.String("123456789012"),
								},
								ResourceArns: pulumi.StringArray{
									pulumi.String("arn:aws:s3:::my-example-bucket"),
								},
							},
						},
					},
				},
			},
			AnalyzerName: pulumi.String("example"),
			Type:         pulumi.String("ORGANIZATION_INTERNAL_ACCESS"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_accessanalyzer_analyzer" "test" {
  configuration = {
    internal_access = {
      analysis_rule = {
        inclusions = [{
          "accountIds"   = ["123456789012"]
          "resourceArns" = ["arn:aws:s3:::my-example-bucket"]
        }]
      }
    }
  }
  analyzer_name = "example"
  type          = "ORGANIZATION_INTERNAL_ACCESS"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.accessanalyzer.Analyzer;
import com.pulumi.aws.accessanalyzer.AnalyzerArgs;
import com.pulumi.aws.accessanalyzer.inputs.AnalyzerConfigurationArgs;
import com.pulumi.aws.accessanalyzer.inputs.AnalyzerConfigurationInternalAccessArgs;
import com.pulumi.aws.accessanalyzer.inputs.AnalyzerConfigurationInternalAccessAnalysisRuleArgs;
import com.pulumi.aws.accessanalyzer.inputs.AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs;
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) {
        var test = new Analyzer("test", AnalyzerArgs.builder()
            .configuration(AnalyzerConfigurationArgs.builder()
                .internalAccess(AnalyzerConfigurationInternalAccessArgs.builder()
                    .analysisRule(AnalyzerConfigurationInternalAccessAnalysisRuleArgs.builder()
                        .inclusions(AnalyzerConfigurationInternalAccessAnalysisRuleInclusionArgs.builder()
                            .accountIds("123456789012")
                            .resourceArns("arn:aws:s3:::my-example-bucket")
                            .build())
                        .build())
                    .build())
                .build())
            .analyzerName("example")
            .type("ORGANIZATION_INTERNAL_ACCESS")
            .build());

    }
}
resources:
  test:
    type: aws:accessanalyzer:Analyzer
    properties:
      configuration:
        internalAccess:
          analysisRule:
            inclusions:
              - accountIds:
                  - '123456789012'
                resourceArns:
                  - arn:aws:s3:::my-example-bucket
      analyzerName: example
      type: ORGANIZATION_INTERNAL_ACCESS

Import

Using pulumi import, import Access Analyzer Analyzers using the analyzerName. For example:

$ pulumi import aws:accessanalyzer/analyzer:Analyzer example example

Constructors

Analyzer(String name, {AnalyzerArgs? args, CustomResourceOptions? options})
Creates a new Analyzer. name The Pulumi resource name. args Arguments used to configure this Analyzer. The set of arguments for Analyzer. options Resource options controlling this resource's behavior.
Analyzer.reference(String urn)
Creates a typed reference to an existing Analyzer resource.

Properties

analyzerName ↔ Output<String>
Name of the Analyzer.
latefinal
arn ↔ Output<String>
ARN of the Analyzer.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
configuration ↔ Output<AnalyzerConfiguration?>
A block that specifies the configuration of the analyzer. See configuration Block for details.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
tags ↔ Output<Map<String, String>?>
Key-value map of resource tags. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
type ↔ Output<String?>
Type that represents the zone of trust or scope for the analyzer. Valid values are ACCOUNT, ACCOUNT_INTERNAL_ACCESS, ACCOUNT_UNUSED_ACCESS, ORGANIZATION, ORGANIZATION_INTERNAL_ACCESS, ORGANIZATION_UNUSED_ACCESS. Defaults to ACCOUNT.
latefinal
urn ↔ Output<String>
latefinalinherited

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {AnalyzerState? state, CustomResourceOptions? options}) → Analyzer
Gets an existing Analyzer resource's state with the given name and id.