Monitor class

Manages a Network Flow Monitor Monitor.

Example Usage

Basic Usage

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

const example = new aws.ec2.Vpc("example", {
    cidrBlock: "10.0.0.0/16",
    tags: {
        Name: "example",
    },
});
const exampleMonitor = new aws.networkflowmonitor.Monitor("example", {
    localResources: [{
        type: "AWS::EC2::VPC",
        identifier: example.arn,
    }],
    remoteResources: [{
        type: "AWS::EC2::VPC",
        identifier: example.arn,
    }],
    monitorName: "example-monitor",
    scopeArn: exampleAwsNetworkflowmonitorScope.scopeArn,
    tags: {
        Name: "example",
    },
});

import pulumi
import pulumi_aws as aws

example = aws.ec2.Vpc("example",
    cidr_block="10.0.0.0/16",
    tags={
        "Name": "example",
    })
example_monitor = aws.networkflowmonitor.Monitor("example",
    local_resources=[{
        "type": "AWS::EC2::VPC",
        "identifier": example.arn,
    }],
    remote_resources=[{
        "type": "AWS::EC2::VPC",
        "identifier": example.arn,
    }],
    monitor_name="example-monitor",
    scope_arn=example_aws_networkflowmonitor_scope["scopeArn"],
    tags={
        "Name": "example",
    })

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

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Ec2.Vpc("example", new()
    {
        CidrBlock = "10.0.0.0/16",
        Tags =
        {
            { "Name", "example" },
        },
    });

    var exampleMonitor = new Aws.Networkflowmonitor.Monitor("example", new()
    {
        LocalResources = new[]
        {
            new Aws.Networkflowmonitor.Inputs.MonitorLocalResourceArgs
            {
                Type = "AWS::EC2::VPC",
                Identifier = example.Arn,
            },
        },
        RemoteResources = new[]
        {
            new Aws.Networkflowmonitor.Inputs.MonitorRemoteResourceArgs
            {
                Type = "AWS::EC2::VPC",
                Identifier = example.Arn,
            },
        },
        MonitorName = "example-monitor",
        ScopeArn = exampleAwsNetworkflowmonitorScope.ScopeArn,
        Tags =
        {
            { "Name", "example" },
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := ec2.NewVpc(ctx, "example", &ec2.VpcArgs{
			CidrBlock: pulumi.String("10.0.0.0/16"),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("example"),
			},
		})
		if err != nil {
			return err
		}
		_, err = networkflowmonitor.NewMonitor(ctx, "example", &networkflowmonitor.MonitorArgs{
			LocalResources: networkflowmonitor.MonitorLocalResourceArray{
				&networkflowmonitor.MonitorLocalResourceArgs{
					Type:       pulumi.String("AWS::EC2::VPC"),
					Identifier: example.Arn,
				},
			},
			RemoteResources: networkflowmonitor.MonitorRemoteResourceArray{
				&networkflowmonitor.MonitorRemoteResourceArgs{
					Type:       pulumi.String("AWS::EC2::VPC"),
					Identifier: example.Arn,
				},
			},
			MonitorName: pulumi.String("example-monitor"),
			ScopeArn:    pulumi.Any(exampleAwsNetworkflowmonitorScope.ScopeArn),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("example"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ec2_vpc" "example" {
  cidr_block = "10.0.0.0/16"
  tags = {
    "Name" = "example"
  }
}
resource "aws_networkflowmonitor_monitor" "example" {
  local_resources {
    type       = "AWS::EC2::VPC"
    identifier = aws_ec2_vpc.example.arn
  }
  remote_resources {
    type       = "AWS::EC2::VPC"
    identifier = aws_ec2_vpc.example.arn
  }
  monitor_name = "example-monitor"
  scope_arn    = exampleAwsNetworkflowmonitorScope.scopeArn
  tags = {
    "Name" = "example"
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.Vpc;
import com.pulumi.aws.ec2.VpcArgs;
import com.pulumi.aws.networkflowmonitor.Monitor;
import com.pulumi.aws.networkflowmonitor.MonitorArgs;
import com.pulumi.aws.networkflowmonitor.inputs.MonitorLocalResourceArgs;
import com.pulumi.aws.networkflowmonitor.inputs.MonitorRemoteResourceArgs;
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 Vpc("example", VpcArgs.builder()
            .cidrBlock("10.0.0.0/16")
            .tags(Map.of("Name", "example"))
            .build());

        var exampleMonitor = new Monitor("exampleMonitor", MonitorArgs.builder()
            .localResources(MonitorLocalResourceArgs.builder()
                .type("AWS::EC2::VPC")
                .identifier(example.arn())
                .build())
            .remoteResources(MonitorRemoteResourceArgs.builder()
                .type("AWS::EC2::VPC")
                .identifier(example.arn())
                .build())
            .monitorName("example-monitor")
            .scopeArn(exampleAwsNetworkflowmonitorScope.scopeArn())
            .tags(Map.of("Name", "example"))
            .build());

    }
}

resources:
  example:
    type: aws:ec2:Vpc
    properties:
      cidrBlock: 10.0.0.0/16
      tags:
        Name: example
  exampleMonitor:
    type: aws:networkflowmonitor:Monitor
    name: example
    properties:
      localResources:
        - type: AWS::EC2::VPC
          identifier: ${example.arn}
      remoteResources:
        - type: AWS::EC2::VPC
          identifier: ${example.arn}
      monitorName: example-monitor
      scopeArn: ${exampleAwsNetworkflowmonitorScope.scopeArn}
      tags:
        Name: example

Import

Using pulumi import, import Network Flow Monitor Monitor using the monitor name. For example:

$ pulumi import aws:networkflowmonitor/monitor:Monitor example example-monitor