signalfx.aws.Integration

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using SignalFx = Pulumi.SignalFx;

return await Deployment.RunAsync(() => 
{
    // This resource returns an account id in `external_id`…
    var awsMyteamExternal = new SignalFx.Aws.ExternalIntegration("awsMyteamExternal");

    // Make yourself an AWS IAM role here, use `signalfx_aws_external_integration.aws_myteam_external.external_id`
    var awsSfxRole = new Aws.Iam.Role("awsSfxRole");

    // Stuff here that uses the external and account ID
    var awsMyteam = new SignalFx.Aws.Integration("awsMyteam", new()
    {
        Enabled = true,
        IntegrationId = awsMyteamExternal.Id,
        ExternalId = awsMyteamExternal.ExternalId,
        RoleArn = awsSfxRole.Arn,
        Regions = new[]
        {
            "us-east-1",
        },
        PollRate = 300,
        ImportCloudWatch = true,
        EnableAwsUsage = true,
        CustomNamespaceSyncRules = new[]
        {
            new SignalFx.Aws.Inputs.IntegrationCustomNamespaceSyncRuleArgs
            {
                DefaultAction = "Exclude",
                FilterAction = "Include",
                FilterSource = "filter('code', '200')",
                Namespace = "my-custom-namespace",
            },
        },
        NamespaceSyncRules = new[]
        {
            new SignalFx.Aws.Inputs.IntegrationNamespaceSyncRuleArgs
            {
                DefaultAction = "Exclude",
                FilterAction = "Include",
                FilterSource = "filter('code', '200')",
                Namespace = "AWS/EC2",
            },
        },
        MetricStatsToSyncs = new[]
        {
            new SignalFx.Aws.Inputs.IntegrationMetricStatsToSyncArgs
            {
                Namespace = "AWS/EC2",
                Metric = "NetworkPacketsIn",
                Stats = new[]
                {
                    "upper",
                },
            },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/iam"
	"github.com/pulumi/pulumi-signalfx/sdk/v5/go/signalfx/aws"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		awsMyteamExternal, err := aws.NewExternalIntegration(ctx, "awsMyteamExternal", nil)
		if err != nil {
			return err
		}
		awsSfxRole, err := iam.NewRole(ctx, "awsSfxRole", nil)
		if err != nil {
			return err
		}
		_, err = aws.NewIntegration(ctx, "awsMyteam", &aws.IntegrationArgs{
			Enabled:       pulumi.Bool(true),
			IntegrationId: awsMyteamExternal.ID(),
			ExternalId:    awsMyteamExternal.ExternalId,
			RoleArn:       awsSfxRole.Arn,
			Regions: pulumi.StringArray{
				pulumi.String("us-east-1"),
			},
			PollRate:         pulumi.Int(300),
			ImportCloudWatch: pulumi.Bool(true),
			EnableAwsUsage:   pulumi.Bool(true),
			CustomNamespaceSyncRules: aws.IntegrationCustomNamespaceSyncRuleArray{
				&aws.IntegrationCustomNamespaceSyncRuleArgs{
					DefaultAction: pulumi.String("Exclude"),
					FilterAction:  pulumi.String("Include"),
					FilterSource:  pulumi.String("filter('code', '200')"),
					Namespace:     pulumi.String("my-custom-namespace"),
				},
			},
			NamespaceSyncRules: aws.IntegrationNamespaceSyncRuleArray{
				&aws.IntegrationNamespaceSyncRuleArgs{
					DefaultAction: pulumi.String("Exclude"),
					FilterAction:  pulumi.String("Include"),
					FilterSource:  pulumi.String("filter('code', '200')"),
					Namespace:     pulumi.String("AWS/EC2"),
				},
			},
			MetricStatsToSyncs: aws.IntegrationMetricStatsToSyncArray{
				&aws.IntegrationMetricStatsToSyncArgs{
					Namespace: pulumi.String("AWS/EC2"),
					Metric:    pulumi.String("NetworkPacketsIn"),
					Stats: pulumi.StringArray{
						pulumi.String("upper"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.signalfx.aws.ExternalIntegration;
import com.pulumi.aws.iam.Role;
import com.pulumi.signalfx.aws.Integration;
import com.pulumi.signalfx.aws.IntegrationArgs;
import com.pulumi.signalfx.aws.inputs.IntegrationCustomNamespaceSyncRuleArgs;
import com.pulumi.signalfx.aws.inputs.IntegrationNamespaceSyncRuleArgs;
import com.pulumi.signalfx.aws.inputs.IntegrationMetricStatsToSyncArgs;
import java.util.List;
import java.util.ArrayList;
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 awsMyteamExternal = new ExternalIntegration("awsMyteamExternal");

        var awsSfxRole = new Role("awsSfxRole");

        var awsMyteam = new Integration("awsMyteam", IntegrationArgs.builder()        
            .enabled(true)
            .integrationId(awsMyteamExternal.id())
            .externalId(awsMyteamExternal.externalId())
            .roleArn(awsSfxRole.arn())
            .regions("us-east-1")
            .pollRate(300)
            .importCloudWatch(true)
            .enableAwsUsage(true)
            .customNamespaceSyncRules(IntegrationCustomNamespaceSyncRuleArgs.builder()
                .defaultAction("Exclude")
                .filterAction("Include")
                .filterSource("filter('code', '200')")
                .namespace("my-custom-namespace")
                .build())
            .namespaceSyncRules(IntegrationNamespaceSyncRuleArgs.builder()
                .defaultAction("Exclude")
                .filterAction("Include")
                .filterSource("filter('code', '200')")
                .namespace("AWS/EC2")
                .build())
            .metricStatsToSyncs(IntegrationMetricStatsToSyncArgs.builder()
                .namespace("AWS/EC2")
                .metric("NetworkPacketsIn")
                .stats("upper")
                .build())
            .build());

    }
}

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

// This resource returns an account id in `external_id`…
const awsMyteamExternal = new signalfx.aws.ExternalIntegration("awsMyteamExternal", {});
// Make yourself an AWS IAM role here, use `signalfx_aws_external_integration.aws_myteam_external.external_id`
const awsSfxRole = new aws.iam.Role("awsSfxRole", {});
// Stuff here that uses the external and account ID
const awsMyteam = new signalfx.aws.Integration("awsMyteam", {
    enabled: true,
    integrationId: awsMyteamExternal.id,
    externalId: awsMyteamExternal.externalId,
    roleArn: awsSfxRole.arn,
    regions: ["us-east-1"],
    pollRate: 300,
    importCloudWatch: true,
    enableAwsUsage: true,
    customNamespaceSyncRules: [{
        defaultAction: "Exclude",
        filterAction: "Include",
        filterSource: "filter('code', '200')",
        namespace: "my-custom-namespace",
    }],
    namespaceSyncRules: [{
        defaultAction: "Exclude",
        filterAction: "Include",
        filterSource: "filter('code', '200')",
        namespace: "AWS/EC2",
    }],
    metricStatsToSyncs: [{
        namespace: "AWS/EC2",
        metric: "NetworkPacketsIn",
        stats: ["upper"],
    }],
});

import pulumi
import pulumi_aws as aws
import pulumi_signalfx as signalfx

# This resource returns an account id in `external_id`…
aws_myteam_external = signalfx.aws.ExternalIntegration("awsMyteamExternal")
# Make yourself an AWS IAM role here, use `signalfx_aws_external_integration.aws_myteam_external.external_id`
aws_sfx_role = aws.iam.Role("awsSfxRole")
# Stuff here that uses the external and account ID
aws_myteam = signalfx.aws.Integration("awsMyteam",
    enabled=True,
    integration_id=aws_myteam_external.id,
    external_id=aws_myteam_external.external_id,
    role_arn=aws_sfx_role.arn,
    regions=["us-east-1"],
    poll_rate=300,
    import_cloud_watch=True,
    enable_aws_usage=True,
    custom_namespace_sync_rules=[signalfx.aws.IntegrationCustomNamespaceSyncRuleArgs(
        default_action="Exclude",
        filter_action="Include",
        filter_source="filter('code', '200')",
        namespace="my-custom-namespace",
    )],
    namespace_sync_rules=[signalfx.aws.IntegrationNamespaceSyncRuleArgs(
        default_action="Exclude",
        filter_action="Include",
        filter_source="filter('code', '200')",
        namespace="AWS/EC2",
    )],
    metric_stats_to_syncs=[signalfx.aws.IntegrationMetricStatsToSyncArgs(
        namespace="AWS/EC2",
        metric="NetworkPacketsIn",
        stats=["upper"],
    )])

resources:
  # This resource returns an account id in `external_id`…
  awsMyteamExternal:
    type: signalfx:aws:ExternalIntegration
  # Make yourself an AWS IAM role here, use `signalfx_aws_external_integration.aws_myteam_external.external_id`
  awsSfxRole:
    type: aws:iam:Role
  awsMyteam:
    type: signalfx:aws:Integration
    properties:
      enabled: true
      integrationId: ${awsMyteamExternal.id}
      externalId: ${awsMyteamExternal.externalId}
      roleArn: ${awsSfxRole.arn}
      regions:
        - us-east-1
      pollRate: 300
      importCloudWatch: true
      enableAwsUsage: true
      customNamespaceSyncRules:
        - defaultAction: Exclude
          filterAction: Include
          filterSource: filter('code', '200')
          namespace: my-custom-namespace
      namespaceSyncRules:
        - defaultAction: Exclude
          filterAction: Include
          filterSource: filter('code', '200')
          namespace: AWS/EC2
      metricStatsToSyncs:
        - namespace: AWS/EC2
          metric: NetworkPacketsIn
          stats:
            - upper