MultiplexProgram class

Resource for managing an AWS MediaLive MultiplexProgram.

Example Usage

Basic Usage

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

const available = aws.getAvailabilityZones({
    state: "available",
});
const example = new aws.medialive.Multiplex("example", {
    multiplexSettings: {
        transportStreamBitrate: 1000000,
        transportStreamId: 1,
        transportStreamReservedBitrate: 1,
        maximumVideoBufferDelayMilliseconds: 1000,
    },
    name: "example-multiplex-changed",
    availabilityZones: [
        available.then(available => available.names?.[0]),
        available.then(available => available.names?.[1]),
    ],
    startMultiplex: true,
    tags: {
        tag1: "value1",
    },
});
const exampleMultiplexProgram = new aws.medialive.MultiplexProgram("example", {
    multiplexProgramSettings: {
        videoSettings: {
            constantBitrate: 100000,
        },
        programNumber: 1,
        preferredChannelPipeline: "CURRENTLY_ACTIVE",
    },
    programName: "example_program",
    multiplexId: example.id,
});
import pulumi
import pulumi_aws as aws

available = aws.get_availability_zones(state="available")
example = aws.medialive.Multiplex("example",
    multiplex_settings={
        "transport_stream_bitrate": 1000000,
        "transport_stream_id": 1,
        "transport_stream_reserved_bitrate": 1,
        "maximum_video_buffer_delay_milliseconds": 1000,
    },
    name="example-multiplex-changed",
    availability_zones=[
        available.names[0],
        available.names[1],
    ],
    start_multiplex=True,
    tags={
        "tag1": "value1",
    })
example_multiplex_program = aws.medialive.MultiplexProgram("example",
    multiplex_program_settings={
        "video_settings": {
            "constant_bitrate": 100000,
        },
        "program_number": 1,
        "preferred_channel_pipeline": "CURRENTLY_ACTIVE",
    },
    program_name="example_program",
    multiplex_id=example.id)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var available = Aws.GetAvailabilityZones.Invoke(new()
    {
        State = "available",
    });

    var example = new Aws.MediaLive.Multiplex("example", new()
    {
        MultiplexSettings = new Aws.MediaLive.Inputs.MultiplexMultiplexSettingsArgs
        {
            TransportStreamBitrate = 1000000,
            TransportStreamId = 1,
            TransportStreamReservedBitrate = 1,
            MaximumVideoBufferDelayMilliseconds = 1000,
        },
        Name = "example-multiplex-changed",
        AvailabilityZones = new[]
        {
            available.Apply(getAvailabilityZonesResult => getAvailabilityZonesResult.Names[0]),
            available.Apply(getAvailabilityZonesResult => getAvailabilityZonesResult.Names[1]),
        },
        StartMultiplex = true,
        Tags =
        {
            { "tag1", "value1" },
        },
    });

    var exampleMultiplexProgram = new Aws.MediaLive.MultiplexProgram("example", new()
    {
        MultiplexProgramSettings = new Aws.MediaLive.Inputs.MultiplexProgramMultiplexProgramSettingsArgs
        {
            VideoSettings = new Aws.MediaLive.Inputs.MultiplexProgramMultiplexProgramSettingsVideoSettingsArgs
            {
                ConstantBitrate = 100000,
            },
            ProgramNumber = 1,
            PreferredChannelPipeline = "CURRENTLY_ACTIVE",
        },
        ProgramName = "example_program",
        MultiplexId = example.Id,
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		available, err := aws.GetAvailabilityZones(ctx, &aws.GetAvailabilityZonesArgs{
			State: pulumi.StringRef("available"),
		}, nil)
		if err != nil {
			return err
		}
		example, err := medialive.NewMultiplex(ctx, "example", &medialive.MultiplexArgs{
			MultiplexSettings: &medialive.MultiplexMultiplexSettingsArgs{
				TransportStreamBitrate:              pulumi.Int(1000000),
				TransportStreamId:                   pulumi.Int(1),
				TransportStreamReservedBitrate:      pulumi.Int(1),
				MaximumVideoBufferDelayMilliseconds: pulumi.Int(1000),
			},
			Name: pulumi.String("example-multiplex-changed"),
			AvailabilityZones: pulumi.StringArray{
				pulumi.String(available.Names[0]),
				pulumi.String(available.Names[1]),
			},
			StartMultiplex: pulumi.Bool(true),
			Tags: pulumi.StringMap{
				"tag1": pulumi.String("value1"),
			},
		})
		if err != nil {
			return err
		}
		_, err = medialive.NewMultiplexProgram(ctx, "example", &medialive.MultiplexProgramArgs{
			MultiplexProgramSettings: &medialive.MultiplexProgramMultiplexProgramSettingsArgs{
				VideoSettings: &medialive.MultiplexProgramMultiplexProgramSettingsVideoSettingsArgs{
					ConstantBitrate: pulumi.Int(100000),
				},
				ProgramNumber:            pulumi.Int(1),
				PreferredChannelPipeline: pulumi.String("CURRENTLY_ACTIVE"),
			},
			ProgramName: pulumi.String("example_program"),
			MultiplexId: example.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_getavailabilityzones" "available" {
  state = "available"
}

resource "aws_medialive_multiplex" "example" {
  multiplex_settings = {
    transport_stream_bitrate                = 1000000
    transport_stream_id                     = 1
    transport_stream_reserved_bitrate       = 1
    maximum_video_buffer_delay_milliseconds = 1000
  }
  name               = "example-multiplex-changed"
  availability_zones = [data.aws_getavailabilityzones.available.names[0], data.aws_getavailabilityzones.available.names[1]]
  start_multiplex    = true
  tags = {
    "tag1" = "value1"
  }
}
resource "aws_medialive_multiplexprogram" "example" {
  multiplex_program_settings = {
    video_settings = {
      constant_bitrate = 100000
    }
    program_number             = 1
    preferred_channel_pipeline = "CURRENTLY_ACTIVE"
  }
  program_name = "example_program"
  multiplex_id = aws_medialive_multiplex.example.id
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.aws.inputs.GetAvailabilityZonesArgs;
import com.pulumi.aws.medialive.Multiplex;
import com.pulumi.aws.medialive.MultiplexArgs;
import com.pulumi.aws.medialive.inputs.MultiplexMultiplexSettingsArgs;
import com.pulumi.aws.medialive.MultiplexProgram;
import com.pulumi.aws.medialive.MultiplexProgramArgs;
import com.pulumi.aws.medialive.inputs.MultiplexProgramMultiplexProgramSettingsArgs;
import com.pulumi.aws.medialive.inputs.MultiplexProgramMultiplexProgramSettingsVideoSettingsArgs;
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) {
        final var available = AwsFunctions.getAvailabilityZones(GetAvailabilityZonesArgs.builder()
            .state("available")
            .build());

        var example = new Multiplex("example", MultiplexArgs.builder()
            .multiplexSettings(MultiplexMultiplexSettingsArgs.builder()
                .transportStreamBitrate(1000000)
                .transportStreamId(1)
                .transportStreamReservedBitrate(1)
                .maximumVideoBufferDelayMilliseconds(1000)
                .build())
            .name("example-multiplex-changed")
            .availabilityZones(
                available.names()[0],
                available.names()[1])
            .startMultiplex(true)
            .tags(Map.of("tag1", "value1"))
            .build());

        var exampleMultiplexProgram = new MultiplexProgram("exampleMultiplexProgram", MultiplexProgramArgs.builder()
            .multiplexProgramSettings(MultiplexProgramMultiplexProgramSettingsArgs.builder()
                .videoSettings(MultiplexProgramMultiplexProgramSettingsVideoSettingsArgs.builder()
                    .constantBitrate(100000)
                    .build())
                .programNumber(1)
                .preferredChannelPipeline("CURRENTLY_ACTIVE")
                .build())
            .programName("example_program")
            .multiplexId(example.id())
            .build());

    }
}
resources:
  example:
    type: aws:medialive:Multiplex
    properties:
      multiplexSettings:
        transportStreamBitrate: 1e+06
        transportStreamId: 1
        transportStreamReservedBitrate: 1
        maximumVideoBufferDelayMilliseconds: 1000
      name: example-multiplex-changed
      availabilityZones:
        - ${available.names[0]}
        - ${available.names[1]}
      startMultiplex: true
      tags:
        tag1: value1
  exampleMultiplexProgram:
    type: aws:medialive:MultiplexProgram
    name: example
    properties:
      multiplexProgramSettings:
        videoSettings:
          constantBitrate: 100000
        programNumber: 1
        preferredChannelPipeline: CURRENTLY_ACTIVE
      programName: example_program
      multiplexId: ${example.id}
variables:
  available:
    fn::invoke:
      function: aws:getAvailabilityZones
      arguments:
        state: available

Import

Identity Schema

Required

  • multiplexId (String) ID of the Multiplex.
  • programName (String) Unique program name.

Optional

  • accountId (String) AWS Account where this resource is managed.
  • region (String) Region where this resource is managed.

Using pulumi import, import MediaLive MultiplexProgram using the id, or a combination of "programName/multiplexId". For example:

$ pulumi import aws:medialive/multiplexProgram:MultiplexProgram example example_program/12345678

Constructors

MultiplexProgram(String name, {MultiplexProgramArgs? args, CustomResourceOptions? options})
Creates a new MultiplexProgram. name The Pulumi resource name. args Arguments used to configure this MultiplexProgram. The set of arguments for MultiplexProgram. options Resource options controlling this resource's behavior.
MultiplexProgram.reference(String urn)
Creates a typed reference to an existing MultiplexProgram resource.

Properties

childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
multiplexId ↔ Output<String>
Multiplex ID.
latefinal
multiplexProgramSettings ↔ Output<MultiplexProgramMultiplexProgramSettings?>
MultiplexProgram settings. See Multiplex Program Settings for more details.
latefinal
programName ↔ Output<String>
Unique program name.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
timeouts ↔ Output<MultiplexProgramTimeouts?>
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {MultiplexProgramState? state, CustomResourceOptions? options}) → MultiplexProgram
Gets an existing MultiplexProgram resource's state with the given name and id.