Skip to content
v2.277.0

Experimental

@aws-cdk/aws-mediaconnect-alpha is an experimental (alpha) package: its API may change in any release, without a major version bump.

MediaLiveInputConnectionProps Struct ​

Properties for MediaLive Router Output configuration with specific input connection.

Example ​

ts
declare const stack: Stack;
declare const mediaLiveInput: medialive.IInput;

// 1. A public network interface for the SRT input
const networkInterface = new RouterNetworkInterface(stack, 'NetworkInterface', {
  routerNetworkInterfaceName: 'camera-network',
  configuration: RouterNetworkConfiguration.publicNetwork({
    cidr: ['203.0.113.0/24'],
  }),
});

// 2. A router input receiving SRT from an upstream encoder
const input = new RouterInput(stack, 'Input', {
  routerInputName: 'camera-input',
  maximumBitrate: Bitrate.mbps(10),
  routingScope: RoutingScope.REGIONAL,
  tier: RouterInputTier.INPUT_20,
  configuration: RouterInputConfiguration.standard({
    networkInterface,
    protocol: RouterInputProtocol.srtListener({
      port: 9000,
      minimumLatency: Duration.millis(200),
    }),
  }),
});

// 3. A router output delivering to MediaLive
const output = new RouterOutput(stack, 'Output', {
  routerOutputName: 'medialive-output',
  maximumBitrate: Bitrate.mbps(10),
  routingScope: RoutingScope.REGIONAL,
  tier: RouterOutputTier.OUTPUT_20,
  configuration: RouterOutputConfiguration.mediaLiveInput({
    input: mediaLiveInput,
    pipeline: MediaLivePipeline.PIPELINE_0,
  }),
});
python
# stack: Stack
# media_live_input: medialive.IInput


# 1. A public network interface for the SRT input
network_interface = RouterNetworkInterface(stack, "NetworkInterface",
    router_network_interface_name="camera-network",
    configuration=RouterNetworkConfiguration.public_network(
        cidr=["203.0.113.0/24"]
    )
)

# 2. A router input receiving SRT from an upstream encoder
input = RouterInput(stack, "Input",
    router_input_name="camera-input",
    maximum_bitrate=Bitrate.mbps(10),
    routing_scope=RoutingScope.REGIONAL,
    tier=RouterInputTier.INPUT_20,
    configuration=RouterInputConfiguration.standard(
        network_interface=network_interface,
        protocol=RouterInputProtocol.srt_listener(
            port=9000,
            minimum_latency=Duration.millis(200)
        )
    )
)

# 3. A router output delivering to MediaLive
output = RouterOutput(stack, "Output",
    router_output_name="medialive-output",
    maximum_bitrate=Bitrate.mbps(10),
    routing_scope=RoutingScope.REGIONAL,
    tier=RouterOutputTier.OUTPUT_20,
    configuration=RouterOutputConfiguration.media_live_input(
        input=media_live_input,
        pipeline=MediaLivePipeline.PIPELINE_0
    )
)
java
Stack stack;
IInput mediaLiveInput;


// 1. A public network interface for the SRT input
RouterNetworkInterface networkInterface = RouterNetworkInterface.Builder.create(stack, "NetworkInterface")
        .routerNetworkInterfaceName("camera-network")
        .configuration(RouterNetworkConfiguration.publicNetwork(PublicNetworkConfigurationProps.builder()
                .cidr(List.of("203.0.113.0/24"))
                .build()))
        .build();

// 2. A router input receiving SRT from an upstream encoder
RouterInput input = RouterInput.Builder.create(stack, "Input")
        .routerInputName("camera-input")
        .maximumBitrate(Bitrate.mbps(10))
        .routingScope(RoutingScope.REGIONAL)
        .tier(RouterInputTier.INPUT_20)
        .configuration(RouterInputConfiguration.standard(StandardConfigurationProps.builder()
                .networkInterface(networkInterface)
                .protocol(RouterInputProtocol.srtListener(SrtListenerProtocolProps.builder()
                        .port(9000)
                        .minimumLatency(Duration.millis(200))
                        .build()))
                .build()))
        .build();

// 3. A router output delivering to MediaLive
RouterOutput output = RouterOutput.Builder.create(stack, "Output")
        .routerOutputName("medialive-output")
        .maximumBitrate(Bitrate.mbps(10))
        .routingScope(RoutingScope.REGIONAL)
        .tier(RouterOutputTier.OUTPUT_20)
        .configuration(RouterOutputConfiguration.mediaLiveInput(MediaLiveInputConnectionProps.builder()
                .input(mediaLiveInput)
                .pipeline(MediaLivePipeline.PIPELINE_0)
                .build()))
        .build();
csharp
// Install: dotnet add package Amazon.CDK.AWS.MediaConnect.Alpha
Stack stack;
IInput mediaLiveInput;


// 1. A public network interface for the SRT input
var networkInterface = new RouterNetworkInterface(stack, "NetworkInterface", new RouterNetworkInterfaceProps {
    RouterNetworkInterfaceName = "camera-network",
    Configuration = RouterNetworkConfiguration.PublicNetwork(new PublicNetworkConfigurationProps {
        Cidr = new [] { "203.0.113.0/24" }
    })
});

// 2. A router input receiving SRT from an upstream encoder
var input = new RouterInput(stack, "Input", new RouterInputProps {
    RouterInputName = "camera-input",
    MaximumBitrate = Bitrate.Mbps(10),
    RoutingScope = RoutingScope.REGIONAL,
    Tier = RouterInputTier.INPUT_20,
    Configuration = RouterInputConfiguration.Standard(new StandardConfigurationProps {
        NetworkInterface = networkInterface,
        Protocol = RouterInputProtocol.SrtListener(new SrtListenerProtocolProps {
            Port = 9000,
            MinimumLatency = Duration.Millis(200)
        })
    })
});

// 3. A router output delivering to MediaLive
var output = new RouterOutput(stack, "Output", new RouterOutputProps {
    RouterOutputName = "medialive-output",
    MaximumBitrate = Bitrate.Mbps(10),
    RoutingScope = RoutingScope.REGIONAL,
    Tier = RouterOutputTier.OUTPUT_20,
    Configuration = RouterOutputConfiguration.MediaLiveInput(new MediaLiveInputConnectionProps {
        Input = mediaLiveInput,
        Pipeline = MediaLivePipeline.PIPELINE_0
    })
});
go
// Install: go get github.com/aws/aws-cdk-go/awsmediaconnectalpha/v2
var stack Stack
var mediaLiveInput IInput


// 1. A public network interface for the SRT input
networkInterface := awsmediaconnectalpha.NewRouterNetworkInterface(stack, jsii.String("NetworkInterface"), &RouterNetworkInterfaceProps{
	RouterNetworkInterfaceName: jsii.String("camera-network"),
	Configuration: awsmediaconnectalpha.RouterNetworkConfiguration_PublicNetwork(&PublicNetworkConfigurationProps{
		Cidr: []*string{
			jsii.String("203.0.113.0/24"),
		},
	}),
})

// 2. A router input receiving SRT from an upstream encoder
input := awsmediaconnectalpha.NewRouterInput(stack, jsii.String("Input"), &RouterInputProps{
	RouterInputName: jsii.String("camera-input"),
	MaximumBitrate: awscdk.Bitrate_Mbps(jsii.Number(10)),
	RoutingScope: awsmediaconnectalpha.RoutingScope_REGIONAL(),
	Tier: awsmediaconnectalpha.RouterInputTier_INPUT_20(),
	Configuration: awsmediaconnectalpha.RouterInputConfiguration_Standard(&StandardConfigurationProps{
		NetworkInterface: *NetworkInterface,
		Protocol: awsmediaconnectalpha.RouterInputProtocol_SrtListener(&SrtListenerProtocolProps{
			Port: jsii.Number(9000),
			MinimumLatency: awscdk.Duration_Millis(jsii.Number(200)),
		}),
	}),
})

// 3. A router output delivering to MediaLive
output := awsmediaconnectalpha.NewRouterOutput(stack, jsii.String("Output"), &RouterOutputProps{
	RouterOutputName: jsii.String("medialive-output"),
	MaximumBitrate: awscdk.Bitrate_*Mbps(jsii.Number(10)),
	RoutingScope: awsmediaconnectalpha.RoutingScope_REGIONAL(),
	Tier: awsmediaconnectalpha.RouterOutputTier_OUTPUT_20(),
	Configuration: awsmediaconnectalpha.RouterOutputConfiguration_MediaLiveInput(&MediaLiveInputConnectionProps{
		Input: mediaLiveInput,
		Pipeline: awsmediaconnectalpha.MediaLivePipeline_PIPELINE_0,
	}),
})

Properties ​

destinationTransitEncryptionoptionalTransitEncryptiondestination_transit_encryptionoptionalTransitEncryptiondestinationTransitEncryptionoptionalTransitEncryptionDestinationTransitEncryptionoptionalTransitEncryptionDestinationTransitEncryptionoptionalTransitEncryption#
Optional transit encryption configuration.

Default: Automatic encryption will be used

inputIInputRefinputIInputRefinputIInputRefInputIInputRefInputIInputRefrequired#
The MediaLive input to send output to (must be of type `medialive.InputConfiguration.mediaConnectRouter()`).
MediaLive pipeline to send output to.