@aws-cdk/aws-medialive-alpha.SrtListenerInputProps

Experimental

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

SrtListenerInputProps Struct

Properties for an SRT listener input.

Stability

Experimental

Source

lib/input.ts

Example

declare const stack: Stack;
declare const passphrase: secretsmanager.ISecret;

const sg = new medialive.InputSecurityGroup(stack, 'SrtSg', {
  allowlistRules: ['203.0.113.0/24'],
});

new medialive.Input(stack, 'SrtListenerInput', {
  inputName: 'srt-listener',
  input: medialive.InputConfiguration.srtListener({
    inputSecurityGroups: [sg],
    minimumLatency: Duration.millis(500),
    streamId: 'my-stream-id',
    decryption: {
      algorithm: medialive.SrtDecryptionAlgorithm.AES256,
      passphraseSecret: passphrase,
    },
  }),
});

# stack: Stack
# passphrase: secretsmanager.ISecret


sg = medialive.InputSecurityGroup(stack, "SrtSg",
    allowlist_rules=["203.0.113.0/24"]
)

medialive.Input(stack, "SrtListenerInput",
    input_name="srt-listener",
    input=medialive.InputConfiguration.srt_listener(
        input_security_groups=[sg],
        minimum_latency=Duration.millis(500),
        stream_id="my-stream-id",
        decryption=medialive.SrtDecryptionProps(
            algorithm=medialive.SrtDecryptionAlgorithm.AES256,
            passphrase_secret=passphrase
        )
    )
)

Stack stack;
ISecret passphrase;


InputSecurityGroup sg = InputSecurityGroup.Builder.create(stack, "SrtSg")
        .allowlistRules(List.of("203.0.113.0/24"))
        .build();

Input.Builder.create(stack, "SrtListenerInput")
        .inputName("srt-listener")
        .input(InputConfiguration.srtListener(SrtListenerInputProps.builder()
                .inputSecurityGroups(List.of(sg))
                .minimumLatency(Duration.millis(500))
                .streamId("my-stream-id")
                .decryption(SrtDecryptionProps.builder()
                        .algorithm(SrtDecryptionAlgorithm.AES256)
                        .passphraseSecret(passphrase)
                        .build())
                .build()))
        .build();

// Install: dotnet add package Amazon.CDK.AWS.MediaLive.Alpha
Stack stack;
ISecret passphrase;


var sg = new InputSecurityGroup(stack, "SrtSg", new InputSecurityGroupProps {
    AllowlistRules = new [] { "203.0.113.0/24" }
});

new Input(stack, "SrtListenerInput", new InputProps {
    InputName = "srt-listener",
    Input = InputConfiguration.SrtListener(new SrtListenerInputProps {
        InputSecurityGroups = new [] { sg },
        MinimumLatency = Duration.Millis(500),
        StreamId = "my-stream-id",
        Decryption = new SrtDecryptionProps {
            Algorithm = SrtDecryptionAlgorithm.AES256,
            PassphraseSecret = passphrase
        }
    })
});

// Install: go get github.com/aws/aws-cdk-go/awsmedialivealpha/v2
var stack Stack
var passphrase ISecret


sg := medialive.NewInputSecurityGroup(stack, jsii.String("SrtSg"), &InputSecurityGroupProps{
	AllowlistRules: []*string{
		jsii.String("203.0.113.0/24"),
	},
})

medialive.NewInput(stack, jsii.String("SrtListenerInput"), &InputProps{
	InputName: jsii.String("srt-listener"),
	Input: medialive.InputConfiguration_SrtListener(&SrtListenerInputProps{
		InputSecurityGroups: []IInputSecurityGroupRef{
			sg,
		},
		MinimumLatency: awscdk.Duration_Millis(jsii.Number(500)),
		StreamId: jsii.String("my-stream-id"),
		Decryption: &SrtDecryptionProps{
			Algorithm: medialive.SrtDecryptionAlgorithm_AES256(),
			PassphraseSecret: passphrase,
		},
	}),
})

Properties

decryption?optionalSrtDecryptionPropsdecryption?optionalSrtDecryptionPropsdecryption?optionalSrtDecryptionPropsDecryption?optionalSrtDecryptionPropsDecryption?optionalSrtDecryptionProps#

Decryption settings for the SRT connection.

Default: no decryption

inputClass?optionalChannelClassinput_class?optionalChannelClassinputClass?optionalChannelClassInputClass?optionalChannelClassInputClass?optionalChannelClass= ChannelClass.SINGLE_PIPELINE#

Whether this is a STANDARD (two-pipeline) or SINGLE_PIPELINE input.

A STANDARD input creates two listener endpoints for pipeline redundancy.

inputSecurityGroupsIInputSecurityGroupRef[]input_security_groupstyping.List[IInputSecurityGroupRef]inputSecurityGroupsList<IInputSecurityGroupRef>InputSecurityGroupsIInputSecurityGroupRef[]InputSecurityGroups*[]IInputSecurityGroupRefrequired#

The input security groups.

Required for SRT listener inputs.

minimumLatency?optionalDurationminimum_latency?optionalDurationminimumLatency?optionalDurationMinimumLatency?optionalDurationMinimumLatency?optionalDuration#

The minimum latency.

Default: service default

streamId?optionalstringstream_id?optionalstrstreamId?optionalStringStreamId?optionalstringStreamId?optional*string#

The stream ID that the upstream system uses when connecting to this listener.

Default: no stream ID