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.

NetworkInterface Class ​

Network interface options.

Example ​

ts
declare const stack: Stack;
declare const role: iam.IRole;
declare const securityGroup: ec2.ISecurityGroup;
declare const subnet: ec2.ISubnet;

const efaInterface = VpcInterface.define({
  vpcInterfaceName: 'efa-interface',
  role: role,
  securityGroups: [securityGroup],
  subnet: subnet,
  networkInterfaceType: NetworkInterface.EFA,  // Required for CDI
});

const videoStream = MediaStream.video({
  mediaStreamId: 1,
  mediaStreamName: 'video',
  videoFormat: MediaVideoFormat.HD_1080P,
  fmtp: {
    exactFramerate: Framerate.FPS_29_97,
    par: PixelAspectRatio.SQUARE,
  },
});

const flow = new Flow(stack, 'MyCdiFlow', {
  flowSize: FlowSize.LARGE_4X,  // Required for CDI and JPEG XS
  vpcInterfaces: [efaInterface],
  mediaStreams: [videoStream],
  source: SourceConfiguration.cdi({
    flowSourceName: 'cdi-source',
    vpcInterface: efaInterface,
    port: 5000,
    maxSyncBuffer: 100,
    mediaStreamSourceConfigurations: [{
      encoding: Encoding.RAW,
      mediaStream: videoStream,
    }],
  }),
});
python
from aws_cdk.aws_mediaconnect_alpha import FmtpVideo, MediaStreamSourceConfigurationCdi
# stack: Stack
# role: iam.IRole
# security_group: ec2.ISecurityGroup
# subnet: ec2.ISubnet


efa_interface = VpcInterface.define(
    vpc_interface_name="efa-interface",
    role=role,
    security_groups=[security_group],
    subnet=subnet,
    network_interface_type=NetworkInterface.EFA
)

video_stream = MediaStream.video(
    media_stream_id=1,
    media_stream_name="video",
    video_format=MediaVideoFormat.HD_1080P,
    fmtp=FmtpVideo(
        exact_framerate=Framerate.FPS_29_97,
        par=PixelAspectRatio.SQUARE
    )
)

flow = Flow(stack, "MyCdiFlow",
    flow_size=FlowSize.LARGE_4X,  # Required for CDI and JPEG XS
    vpc_interfaces=[efa_interface],
    media_streams=[video_stream],
    source=SourceConfiguration.cdi(
        flow_source_name="cdi-source",
        vpc_interface=efa_interface,
        port=5000,
        max_sync_buffer=100,
        media_stream_source_configurations=[MediaStreamSourceConfigurationCdi(
            encoding=Encoding.RAW,
            media_stream=video_stream
        )]
    )
)
java
Stack stack;
IRole role;
ISecurityGroup securityGroup;
ISubnet subnet;


VpcInterfaceConfig efaInterface = VpcInterface.define(VpcInterfaceDefineProps.builder()
        .vpcInterfaceName("efa-interface")
        .role(role)
        .securityGroups(List.of(securityGroup))
        .subnet(subnet)
        .networkInterfaceType(NetworkInterface.EFA)
        .build());

MediaStream videoStream = MediaStream.video(MediaStreamVideo.builder()
        .mediaStreamId(1)
        .mediaStreamName("video")
        .videoFormat(MediaVideoFormat.HD_1080P)
        .fmtp(FmtpVideo.builder()
                .exactFramerate(Framerate.FPS_29_97)
                .par(PixelAspectRatio.SQUARE)
                .build())
        .build());

Flow flow = Flow.Builder.create(stack, "MyCdiFlow")
        .flowSize(FlowSize.LARGE_4X) // Required for CDI and JPEG XS
        .vpcInterfaces(List.of(efaInterface))
        .mediaStreams(List.of(videoStream))
        .source(SourceConfiguration.cdi(SourceCdi.builder()
                .flowSourceName("cdi-source")
                .vpcInterface(efaInterface)
                .port(5000)
                .maxSyncBuffer(100)
                .mediaStreamSourceConfigurations(List.of(MediaStreamSourceConfigurationCdi.builder()
                        .encoding(Encoding.RAW)
                        .mediaStream(videoStream)
                        .build()))
                .build()))
        .build();
csharp
// Install: dotnet add package Amazon.CDK.AWS.MediaConnect.Alpha
Stack stack;
IRole role;
ISecurityGroup securityGroup;
ISubnet subnet;


var efaInterface = VpcInterface.Define(new VpcInterfaceDefineProps {
    VpcInterfaceName = "efa-interface",
    Role = role,
    SecurityGroups = new [] { securityGroup },
    Subnet = subnet,
    NetworkInterfaceType = NetworkInterface.EFA
});

var videoStream = MediaStream.Video(new MediaStreamVideo {
    MediaStreamId = 1,
    MediaStreamName = "video",
    VideoFormat = MediaVideoFormat.HD_1080P,
    Fmtp = new FmtpVideo {
        ExactFramerate = Framerate.FPS_29_97,
        Par = PixelAspectRatio.SQUARE
    }
});

var flow = new Flow(stack, "MyCdiFlow", new FlowProps {
    FlowSize = FlowSize.LARGE_4X,  // Required for CDI and JPEG XS
    VpcInterfaces = new [] { efaInterface },
    MediaStreams = new [] { videoStream },
    Source = SourceConfiguration.Cdi(new SourceCdi {
        FlowSourceName = "cdi-source",
        VpcInterface = efaInterface,
        Port = 5000,
        MaxSyncBuffer = 100,
        MediaStreamSourceConfigurations = new [] { new MediaStreamSourceConfigurationCdi {
            Encoding = Encoding.RAW,
            MediaStream = videoStream
        } }
    })
});
go
// Install: go get github.com/aws/aws-cdk-go/awsmediaconnectalpha/v2
var stack Stack
var role IRole
var securityGroup ISecurityGroup
var subnet ISubnet


efaInterface := awsmediaconnectalpha.VpcInterface_Define(&VpcInterfaceDefineProps{
	VpcInterfaceName: jsii.String("efa-interface"),
	Role: role,
	SecurityGroups: []ISecurityGroup{
		securityGroup,
	},
	Subnet: subnet,
	NetworkInterfaceType: awsmediaconnectalpha.NetworkInterface_EFA(),
})

videoStream := awsmediaconnectalpha.MediaStream_Video(&MediaStreamVideo{
	MediaStreamId: jsii.Number(1),
	MediaStreamName: jsii.String("video"),
	VideoFormat: awsmediaconnectalpha.MediaVideoFormat_HD_1080P(),
	Fmtp: &FmtpVideo{
		ExactFramerate: awsmediaconnectalpha.Framerate_FPS_29_97(),
		Par: awsmediaconnectalpha.PixelAspectRatio_SQUARE(),
	},
})

flow := awsmediaconnectalpha.NewFlow(stack, jsii.String("MyCdiFlow"), &FlowProps{
	FlowSize: awsmediaconnectalpha.FlowSize_LARGE_4X(),
	 // Required for CDI and JPEG XS
	VpcInterfaces: []VpcInterfaceConfig{
		efaInterface,
	},
	MediaStreams: []MediaStream{
		videoStream,
	},
	Source: awsmediaconnectalpha.SourceConfiguration_Cdi(&SourceCdi{
		FlowSourceName: jsii.String("cdi-source"),
		VpcInterface: efaInterface,
		Port: jsii.Number(5000),
		MaxSyncBuffer: jsii.Number(100),
		MediaStreamSourceConfigurations: []MediaStreamSourceConfigurationCdi{
			&MediaStreamSourceConfigurationCdi{
				Encoding: awsmediaconnectalpha.Encoding_RAW(),
				MediaStream: videoStream,
			},
		},
	}),
})

Properties ​

Option for EFA.

For CDI ensure you use EFA.

valuestringvaluestrvalueStringValuestringValue*string#
The network interface string value.

Methods ​

of(value: string): NetworkInterface // chainable@staticmethod def of(value: str) -> NetworkInterfacepublic static NetworkInterface of(String value)public static NetworkInterface Of(string value)func Of(Value *string) NetworkInterfacestatic#
Use a custom network interface value.
1 parameter

Parameters

  • valuevaluevaluevalueValue — The network interface string value.
toString(): stringdef to_string(self, ) -> strpublic String toString()public string ToString()func ToString() *string#
Returns the string value.