jetstream 0.2.0, Apr 14 25

jetstream 0.2.0 published on Monday, Apr 14, 2025 by nats-io

jetstream.Consumer

Explore with Pulumi AI

jetstream 0.2.0 published on Monday, Apr 14, 2025 by nats-io

Example Usage

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

const oRDERS = new jetstream.Stream("oRDERS", {
    subjects: ["ORDERS.*"],
    storage: "file",
    maxAge: 60 * 60 * 24 * 365,
});
const oRDERSNEW = new jetstream.Consumer("oRDERSNEW", {
    streamId: oRDERS.streamId,
    durableName: "NEW",
    deliverAll: true,
    filterSubject: "ORDERS.received",
    sampleFreq: 100,
});

import pulumi
import pulumi_jetstream as jetstream

o_rders = jetstream.Stream("oRDERS",
    subjects=["ORDERS.*"],
    storage="file",
    max_age=60 * 60 * 24 * 365)
o_rdersnew = jetstream.Consumer("oRDERSNEW",
    stream_id=o_rders.stream_id,
    durable_name="NEW",
    deliver_all=True,
    filter_subject="ORDERS.received",
    sample_freq=100)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/jetstream/jetstream"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		oRDERS, err := jetstream.NewStream(ctx, "oRDERS", &jetstream.StreamArgs{
			Subjects: pulumi.StringArray{
				pulumi.String("ORDERS.*"),
			},
			Storage: pulumi.String("file"),
			MaxAge:  60 * 60 * 24 * 365,
		})
		if err != nil {
			return err
		}
		_, err = jetstream.NewConsumer(ctx, "oRDERSNEW", &jetstream.ConsumerArgs{
			StreamId:      oRDERS.StreamId,
			DurableName:   pulumi.String("NEW"),
			DeliverAll:    pulumi.Bool(true),
			FilterSubject: pulumi.String("ORDERS.received"),
			SampleFreq:    pulumi.Float64(100),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var oRDERS = new Jetstream.Stream("oRDERS", new()
    {
        Subjects = new[]
        {
            "ORDERS.*",
        },
        Storage = "file",
        MaxAge = 60 * 60 * 24 * 365,
    });

    var oRDERSNEW = new Jetstream.Consumer("oRDERSNEW", new()
    {
        StreamId = oRDERS.StreamId,
        DurableName = "NEW",
        DeliverAll = true,
        FilterSubject = "ORDERS.received",
        SampleFreq = 100,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.jetstream.Stream;
import com.pulumi.jetstream.StreamArgs;
import com.pulumi.jetstream.Consumer;
import com.pulumi.jetstream.ConsumerArgs;
import java.util.List;
import java.util.ArrayList;
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 oRDERS = new Stream("oRDERS", StreamArgs.builder()
            .subjects("ORDERS.*")
            .storage("file")
            .maxAge(60 * 60 * 24 * 365)
            .build());

        var oRDERSNEW = new Consumer("oRDERSNEW", ConsumerArgs.builder()
            .streamId(oRDERS.streamId())
            .durableName("NEW")
            .deliverAll(true)
            .filterSubject("ORDERS.received")
            .sampleFreq(100)
            .build());

    }
}

Coming soon!

Attribute Reference

description - (optional) Contains additional information about this consumer
metadata - (optional) A map of strings with arbitrary metadata for the consumer
ack_policy - (optional) The delivery acknowledgement policy to apply to the Consumer
ack_wait - (optional) Number of seconds to wait for acknowledgement
deliver_all - (optional) Starts at the first available message in the Stream
deliver_last - (optional) Starts at the latest available message in the Stream
delivery_subject - (optional) The subject where a Push-based consumer will deliver messages
delivery_group - (optional) When set Push consumers will only deliver messages to subscriptions with this group set
durable_name - The durable name of the Consumer
filter_subject - (optional) Only receive a subset of messages from the Stream based on the subject they entered the Stream on
filter_subjects - (optional) Only receive a subset tof messages from the Stream based on subjects they entered the Stream on. This is exclusive to filter_subject. Only works with v2.10 or better.
max_delivery - (optional) Maximum deliveries to attempt for each message
replay_policy - (optional) The rate at which messages will be replayed from the stream
sample_freq - (optional) The percentage of acknowledgements that will be sampled for observability purposes
start_time - (optional) The timestamp of the first message that will be delivered by this Consumer
stream_id - The name of the Stream that this consumer consumes
stream_sequence - (optional) The Stream Sequence that will be the first message delivered by this Consumer
ratelimit - (optional) The rate limit for delivering messages to push consumers, expressed in bits per second
heartbeat - (optional) Enable heartbeat messages for push consumers, duration specified in seconds
flow_control - (optional) Enable flow control for push consumers
max_waiting - (optional) The number of pulls that can be outstanding on a pull consumer, pulls received after this is reached are ignored
headers_only - (optional) When true no message bodies will be delivered only headers
max_batch - (optional) Limits Pull Batch sizes to this maximum
max_bytes - (optional)The maximum bytes value that maybe set when dong a pull on a Pull Consumer
max_expires - (optional) Limits the Pull Expires duration to this maximum in seconds
inactive_threshold - (optional) Removes the consumer after a idle period, specified as a duration in seconds
max_ack_pending - (optional) Maximum pending Acks before consumers are paused
replicas - (optional) How many replicas of the data to keep in a clustered environment
memory - (optional) Force the consumer state to be kept in memory rather than inherit the setting from the stream
backoff - (optional) List of durations in Go format that represents a retry time scale for NaK’d messages. A list of durations in seconds

Create Consumer Resource

Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

Constructor syntax

new Consumer(name: string, args: ConsumerArgs, opts?: CustomResourceOptions);

@overload
def Consumer(resource_name: str,
             args: ConsumerArgs,
             opts: Optional[ResourceOptions] = None)

@overload
def Consumer(resource_name: str,
             opts: Optional[ResourceOptions] = None,
             durable_name: Optional[str] = None,
             stream_id: Optional[str] = None,
             heartbeat: Optional[float] = None,
             max_ack_pending: Optional[float] = None,
             deliver_all: Optional[bool] = None,
             deliver_last: Optional[bool] = None,
             deliver_last_per_subject: Optional[bool] = None,
             deliver_new: Optional[bool] = None,
             delivery_group: Optional[str] = None,
             delivery_subject: Optional[str] = None,
             description: Optional[str] = None,
             backoffs: Optional[Sequence[float]] = None,
             filter_subject: Optional[str] = None,
             filter_subjects: Optional[Sequence[str]] = None,
             flow_control: Optional[bool] = None,
             headers_only: Optional[bool] = None,
             consumer_id: Optional[str] = None,
             ack_policy: Optional[str] = None,
             max_bytes: Optional[float] = None,
             max_batch: Optional[float] = None,
             inactive_threshold: Optional[float] = None,
             max_delivery: Optional[float] = None,
             max_expires: Optional[float] = None,
             max_waiting: Optional[float] = None,
             memory: Optional[bool] = None,
             metadata: Optional[Mapping[str, str]] = None,
             ratelimit: Optional[float] = None,
             replay_policy: Optional[str] = None,
             replicas: Optional[float] = None,
             sample_freq: Optional[float] = None,
             start_time: Optional[str] = None,
             ack_wait: Optional[float] = None,
             stream_sequence: Optional[float] = None)

func NewConsumer(ctx *Context, name string, args ConsumerArgs, opts ...ResourceOption) (*Consumer, error)

public Consumer(string name, ConsumerArgs args, CustomResourceOptions? opts = null)

public Consumer(String name, ConsumerArgs args)
public Consumer(String name, ConsumerArgs args, CustomResourceOptions options)

type: jetstream:Consumer
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

Parameters

name string: The unique name of the resource.
args ConsumerArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

resource_name str: The unique name of the resource.
args ConsumerArgs: The arguments to resource properties.
opts ResourceOptions: Bag of options to control resource's behavior.

ctx Context: Context object for the current deployment.
name string: The unique name of the resource.
args ConsumerArgs: The arguments to resource properties.
opts ResourceOption: Bag of options to control resource's behavior.

name string: The unique name of the resource.
args ConsumerArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

name String: The unique name of the resource.
args ConsumerArgs: The arguments to resource properties.
options CustomResourceOptions: Bag of options to control resource's behavior.

Constructor example

The following reference example uses placeholder values for all input properties.

var consumerResource = new Jetstream.Consumer("consumerResource", new()
{
    DurableName = "string",
    StreamId = "string",
    Heartbeat = 0,
    MaxAckPending = 0,
    DeliverAll = false,
    DeliverLast = false,
    DeliverLastPerSubject = false,
    DeliverNew = false,
    DeliveryGroup = "string",
    DeliverySubject = "string",
    Description = "string",
    Backoffs = new[]
    {
        0,
    },
    FilterSubject = "string",
    FilterSubjects = new[]
    {
        "string",
    },
    FlowControl = false,
    HeadersOnly = false,
    ConsumerId = "string",
    AckPolicy = "string",
    MaxBytes = 0,
    MaxBatch = 0,
    InactiveThreshold = 0,
    MaxDelivery = 0,
    MaxExpires = 0,
    MaxWaiting = 0,
    Memory = false,
    Metadata = 
    {
        { "string", "string" },
    },
    Ratelimit = 0,
    ReplayPolicy = "string",
    Replicas = 0,
    SampleFreq = 0,
    StartTime = "string",
    AckWait = 0,
    StreamSequence = 0,
});

example, err := jetstream.NewConsumer(ctx, "consumerResource", &jetstream.ConsumerArgs{
	DurableName:           pulumi.String("string"),
	StreamId:              pulumi.String("string"),
	Heartbeat:             pulumi.Float64(0),
	MaxAckPending:         pulumi.Float64(0),
	DeliverAll:            pulumi.Bool(false),
	DeliverLast:           pulumi.Bool(false),
	DeliverLastPerSubject: pulumi.Bool(false),
	DeliverNew:            pulumi.Bool(false),
	DeliveryGroup:         pulumi.String("string"),
	DeliverySubject:       pulumi.String("string"),
	Description:           pulumi.String("string"),
	Backoffs: pulumi.Float64Array{
		pulumi.Float64(0),
	},
	FilterSubject: pulumi.String("string"),
	FilterSubjects: pulumi.StringArray{
		pulumi.String("string"),
	},
	FlowControl:       pulumi.Bool(false),
	HeadersOnly:       pulumi.Bool(false),
	ConsumerId:        pulumi.String("string"),
	AckPolicy:         pulumi.String("string"),
	MaxBytes:          pulumi.Float64(0),
	MaxBatch:          pulumi.Float64(0),
	InactiveThreshold: pulumi.Float64(0),
	MaxDelivery:       pulumi.Float64(0),
	MaxExpires:        pulumi.Float64(0),
	MaxWaiting:        pulumi.Float64(0),
	Memory:            pulumi.Bool(false),
	Metadata: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Ratelimit:      pulumi.Float64(0),
	ReplayPolicy:   pulumi.String("string"),
	Replicas:       pulumi.Float64(0),
	SampleFreq:     pulumi.Float64(0),
	StartTime:      pulumi.String("string"),
	AckWait:        pulumi.Float64(0),
	StreamSequence: pulumi.Float64(0),
})

var consumerResource = new Consumer("consumerResource", ConsumerArgs.builder()
    .durableName("string")
    .streamId("string")
    .heartbeat(0)
    .maxAckPending(0)
    .deliverAll(false)
    .deliverLast(false)
    .deliverLastPerSubject(false)
    .deliverNew(false)
    .deliveryGroup("string")
    .deliverySubject("string")
    .description("string")
    .backoffs(0)
    .filterSubject("string")
    .filterSubjects("string")
    .flowControl(false)
    .headersOnly(false)
    .consumerId("string")
    .ackPolicy("string")
    .maxBytes(0)
    .maxBatch(0)
    .inactiveThreshold(0)
    .maxDelivery(0)
    .maxExpires(0)
    .maxWaiting(0)
    .memory(false)
    .metadata(Map.of("string", "string"))
    .ratelimit(0)
    .replayPolicy("string")
    .replicas(0)
    .sampleFreq(0)
    .startTime("string")
    .ackWait(0)
    .streamSequence(0)
    .build());

consumer_resource = jetstream.Consumer("consumerResource",
    durable_name="string",
    stream_id="string",
    heartbeat=0,
    max_ack_pending=0,
    deliver_all=False,
    deliver_last=False,
    deliver_last_per_subject=False,
    deliver_new=False,
    delivery_group="string",
    delivery_subject="string",
    description="string",
    backoffs=[0],
    filter_subject="string",
    filter_subjects=["string"],
    flow_control=False,
    headers_only=False,
    consumer_id="string",
    ack_policy="string",
    max_bytes=0,
    max_batch=0,
    inactive_threshold=0,
    max_delivery=0,
    max_expires=0,
    max_waiting=0,
    memory=False,
    metadata={
        "string": "string",
    },
    ratelimit=0,
    replay_policy="string",
    replicas=0,
    sample_freq=0,
    start_time="string",
    ack_wait=0,
    stream_sequence=0)

const consumerResource = new jetstream.Consumer("consumerResource", {
    durableName: "string",
    streamId: "string",
    heartbeat: 0,
    maxAckPending: 0,
    deliverAll: false,
    deliverLast: false,
    deliverLastPerSubject: false,
    deliverNew: false,
    deliveryGroup: "string",
    deliverySubject: "string",
    description: "string",
    backoffs: [0],
    filterSubject: "string",
    filterSubjects: ["string"],
    flowControl: false,
    headersOnly: false,
    consumerId: "string",
    ackPolicy: "string",
    maxBytes: 0,
    maxBatch: 0,
    inactiveThreshold: 0,
    maxDelivery: 0,
    maxExpires: 0,
    maxWaiting: 0,
    memory: false,
    metadata: {
        string: "string",
    },
    ratelimit: 0,
    replayPolicy: "string",
    replicas: 0,
    sampleFreq: 0,
    startTime: "string",
    ackWait: 0,
    streamSequence: 0,
});

type: jetstream:Consumer
properties:
    ackPolicy: string
    ackWait: 0
    backoffs:
        - 0
    consumerId: string
    deliverAll: false
    deliverLast: false
    deliverLastPerSubject: false
    deliverNew: false
    deliveryGroup: string
    deliverySubject: string
    description: string
    durableName: string
    filterSubject: string
    filterSubjects:
        - string
    flowControl: false
    headersOnly: false
    heartbeat: 0
    inactiveThreshold: 0
    maxAckPending: 0
    maxBatch: 0
    maxBytes: 0
    maxDelivery: 0
    maxExpires: 0
    maxWaiting: 0
    memory: false
    metadata:
        string: string
    ratelimit: 0
    replayPolicy: string
    replicas: 0
    sampleFreq: 0
    startTime: string
    streamId: string
    streamSequence: 0

Consumer Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

Inputs

In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

The Consumer resource accepts the following input properties:

DurableName string: The durable name of the Consumer
StreamId string: The name of the Stream that this consumer consumes
AckPolicy string: The delivery acknowledgement policy to apply to the Consumer
AckWait double: Number of seconds to wait for acknowledgement
Backoffs List<double>: List of durations in Go format that represents a retry time scale for NaK'd messages. A list of durations in seconds.
ConsumerId string
DeliverAll bool: Starts at the first available message in the Stream
DeliverLast bool: Starts at the latest available message in the Stream
DeliverLastPerSubject bool: Starts with the last message for each subject matched by filter
DeliverNew bool: Starts with the next available message in the Stream
DeliveryGroup string: When set Push consumers will only deliver messages to subscriptions with this group set
DeliverySubject string: The subject where a Push-based consumer will deliver messages
Description string: Contains additional information about this consumer
FilterSubject string: Only receive a subset of messages from the Stream based on the subject they entered the Stream on
FilterSubjects List<string>: Only receive a subset of messages from the stream baseed on the subjects they entered the Streeam on, exlusive to filter_subject and works with nats-server v2.10 or better
FlowControl bool: Enable flow control for push consumers
HeadersOnly bool: When true no message bodies will be delivered only headers
Heartbeat double: Enable heartbeat messages for push consumers, duration specified in seconds
InactiveThreshold double: Removes the consumer after a idle period, specified as a duration in seconds
MaxAckPending double: Maximum pending Acks before consumers are paused
MaxBatch double: Limits Pull Batch sizes to this maximum
MaxBytes double: The maximum bytes value that maybe set when dong a pull on a Pull Consumer
MaxDelivery double: Maximum deliveries to attempt for each message
MaxExpires double: Limits the Pull Expires duration to this maximum in seconds
MaxWaiting double: The number of pulls that can be outstanding on a pull consumer, pulls received after this is reached are ignored
Memory bool: Force the consumer state to be kept in memory rather than inherit the setting from the stream
Metadata Dictionary<string, string>: Free form metadata about the consumer
Ratelimit double: The rate limit for delivering messages to push consumers, expressed in bits per second
ReplayPolicy string: The rate at which messages will be replayed from the stream
Replicas double: How many replicas of the data to keep in a clustered environment
SampleFreq double: The percentage of acknowledgements that will be sampled for observability purposes
StartTime string: The timestamp of the first message that will be delivered by this Consumer
StreamSequence double: The Stream Sequence that will be the first message delivered by this Consumer

DurableName string: The durable name of the Consumer
StreamId string: The name of the Stream that this consumer consumes
AckPolicy string: The delivery acknowledgement policy to apply to the Consumer
AckWait float64: Number of seconds to wait for acknowledgement
Backoffs []float64: List of durations in Go format that represents a retry time scale for NaK'd messages. A list of durations in seconds.
ConsumerId string
DeliverAll bool: Starts at the first available message in the Stream
DeliverLast bool: Starts at the latest available message in the Stream
DeliverLastPerSubject bool: Starts with the last message for each subject matched by filter
DeliverNew bool: Starts with the next available message in the Stream
DeliveryGroup string: When set Push consumers will only deliver messages to subscriptions with this group set
DeliverySubject string: The subject where a Push-based consumer will deliver messages
Description string: Contains additional information about this consumer
FilterSubject string: Only receive a subset of messages from the Stream based on the subject they entered the Stream on
FilterSubjects []string: Only receive a subset of messages from the stream baseed on the subjects they entered the Streeam on, exlusive to filter_subject and works with nats-server v2.10 or better
FlowControl bool: Enable flow control for push consumers
HeadersOnly bool: When true no message bodies will be delivered only headers
Heartbeat float64: Enable heartbeat messages for push consumers, duration specified in seconds
InactiveThreshold float64: Removes the consumer after a idle period, specified as a duration in seconds
MaxAckPending float64: Maximum pending Acks before consumers are paused
MaxBatch float64: Limits Pull Batch sizes to this maximum
MaxBytes float64: The maximum bytes value that maybe set when dong a pull on a Pull Consumer
MaxDelivery float64: Maximum deliveries to attempt for each message
MaxExpires float64: Limits the Pull Expires duration to this maximum in seconds
MaxWaiting float64: The number of pulls that can be outstanding on a pull consumer, pulls received after this is reached are ignored
Memory bool: Force the consumer state to be kept in memory rather than inherit the setting from the stream
Metadata map[string]string: Free form metadata about the consumer
Ratelimit float64: The rate limit for delivering messages to push consumers, expressed in bits per second
ReplayPolicy string: The rate at which messages will be replayed from the stream
Replicas float64: How many replicas of the data to keep in a clustered environment
SampleFreq float64: The percentage of acknowledgements that will be sampled for observability purposes
StartTime string: The timestamp of the first message that will be delivered by this Consumer
StreamSequence float64: The Stream Sequence that will be the first message delivered by this Consumer

durableName String: The durable name of the Consumer
streamId String: The name of the Stream that this consumer consumes
ackPolicy String: The delivery acknowledgement policy to apply to the Consumer
ackWait Double: Number of seconds to wait for acknowledgement
backoffs List<Double>: List of durations in Go format that represents a retry time scale for NaK'd messages. A list of durations in seconds.
consumerId String
deliverAll Boolean: Starts at the first available message in the Stream
deliverLast Boolean: Starts at the latest available message in the Stream
deliverLastPerSubject Boolean: Starts with the last message for each subject matched by filter
deliverNew Boolean: Starts with the next available message in the Stream
deliveryGroup String: When set Push consumers will only deliver messages to subscriptions with this group set
deliverySubject String: The subject where a Push-based consumer will deliver messages
description String: Contains additional information about this consumer
filterSubject String: Only receive a subset of messages from the Stream based on the subject they entered the Stream on
filterSubjects List<String>: Only receive a subset of messages from the stream baseed on the subjects they entered the Streeam on, exlusive to filter_subject and works with nats-server v2.10 or better
flowControl Boolean: Enable flow control for push consumers
headersOnly Boolean: When true no message bodies will be delivered only headers
heartbeat Double: Enable heartbeat messages for push consumers, duration specified in seconds
inactiveThreshold Double: Removes the consumer after a idle period, specified as a duration in seconds
maxAckPending Double: Maximum pending Acks before consumers are paused
maxBatch Double: Limits Pull Batch sizes to this maximum
maxBytes Double: The maximum bytes value that maybe set when dong a pull on a Pull Consumer
maxDelivery Double: Maximum deliveries to attempt for each message
maxExpires Double: Limits the Pull Expires duration to this maximum in seconds
maxWaiting Double: The number of pulls that can be outstanding on a pull consumer, pulls received after this is reached are ignored
memory Boolean: Force the consumer state to be kept in memory rather than inherit the setting from the stream
metadata Map<String,String>: Free form metadata about the consumer
ratelimit Double: The rate limit for delivering messages to push consumers, expressed in bits per second
replayPolicy String: The rate at which messages will be replayed from the stream
replicas Double: How many replicas of the data to keep in a clustered environment
sampleFreq Double: The percentage of acknowledgements that will be sampled for observability purposes
startTime String: The timestamp of the first message that will be delivered by this Consumer
streamSequence Double: The Stream Sequence that will be the first message delivered by this Consumer

durableName string: The durable name of the Consumer
streamId string: The name of the Stream that this consumer consumes
ackPolicy string: The delivery acknowledgement policy to apply to the Consumer
ackWait number: Number of seconds to wait for acknowledgement
backoffs number[]: List of durations in Go format that represents a retry time scale for NaK'd messages. A list of durations in seconds.
consumerId string
deliverAll boolean: Starts at the first available message in the Stream
deliverLast boolean: Starts at the latest available message in the Stream
deliverLastPerSubject boolean: Starts with the last message for each subject matched by filter
deliverNew boolean: Starts with the next available message in the Stream
deliveryGroup string: When set Push consumers will only deliver messages to subscriptions with this group set
deliverySubject string: The subject where a Push-based consumer will deliver messages
description string: Contains additional information about this consumer
filterSubject string: Only receive a subset of messages from the Stream based on the subject they entered the Stream on
filterSubjects string[]: Only receive a subset of messages from the stream baseed on the subjects they entered the Streeam on, exlusive to filter_subject and works with nats-server v2.10 or better
flowControl boolean: Enable flow control for push consumers
headersOnly boolean: When true no message bodies will be delivered only headers
heartbeat number: Enable heartbeat messages for push consumers, duration specified in seconds
inactiveThreshold number: Removes the consumer after a idle period, specified as a duration in seconds
maxAckPending number: Maximum pending Acks before consumers are paused
maxBatch number: Limits Pull Batch sizes to this maximum
maxBytes number: The maximum bytes value that maybe set when dong a pull on a Pull Consumer
maxDelivery number: Maximum deliveries to attempt for each message
maxExpires number: Limits the Pull Expires duration to this maximum in seconds
maxWaiting number: The number of pulls that can be outstanding on a pull consumer, pulls received after this is reached are ignored
memory boolean: Force the consumer state to be kept in memory rather than inherit the setting from the stream
metadata {[key: string]: string}: Free form metadata about the consumer
ratelimit number: The rate limit for delivering messages to push consumers, expressed in bits per second
replayPolicy string: The rate at which messages will be replayed from the stream
replicas number: How many replicas of the data to keep in a clustered environment
sampleFreq number: The percentage of acknowledgements that will be sampled for observability purposes
startTime string: The timestamp of the first message that will be delivered by this Consumer
streamSequence number: The Stream Sequence that will be the first message delivered by this Consumer

durable_name str: The durable name of the Consumer
stream_id str: The name of the Stream that this consumer consumes
ack_policy str: The delivery acknowledgement policy to apply to the Consumer
ack_wait float: Number of seconds to wait for acknowledgement
backoffs Sequence[float]: List of durations in Go format that represents a retry time scale for NaK'd messages. A list of durations in seconds.
consumer_id str
deliver_all bool: Starts at the first available message in the Stream
deliver_last bool: Starts at the latest available message in the Stream
deliver_last_per_subject bool: Starts with the last message for each subject matched by filter
deliver_new bool: Starts with the next available message in the Stream
delivery_group str: When set Push consumers will only deliver messages to subscriptions with this group set
delivery_subject str: The subject where a Push-based consumer will deliver messages
description str: Contains additional information about this consumer
filter_subject str: Only receive a subset of messages from the Stream based on the subject they entered the Stream on
filter_subjects Sequence[str]: Only receive a subset of messages from the stream baseed on the subjects they entered the Streeam on, exlusive to filter_subject and works with nats-server v2.10 or better
flow_control bool: Enable flow control for push consumers
headers_only bool: When true no message bodies will be delivered only headers
heartbeat float: Enable heartbeat messages for push consumers, duration specified in seconds
inactive_threshold float: Removes the consumer after a idle period, specified as a duration in seconds
max_ack_pending float: Maximum pending Acks before consumers are paused
max_batch float: Limits Pull Batch sizes to this maximum
max_bytes float: The maximum bytes value that maybe set when dong a pull on a Pull Consumer
max_delivery float: Maximum deliveries to attempt for each message
max_expires float: Limits the Pull Expires duration to this maximum in seconds
max_waiting float: The number of pulls that can be outstanding on a pull consumer, pulls received after this is reached are ignored
memory bool: Force the consumer state to be kept in memory rather than inherit the setting from the stream
metadata Mapping[str, str]: Free form metadata about the consumer
ratelimit float: The rate limit for delivering messages to push consumers, expressed in bits per second
replay_policy str: The rate at which messages will be replayed from the stream
replicas float: How many replicas of the data to keep in a clustered environment
sample_freq float: The percentage of acknowledgements that will be sampled for observability purposes
start_time str: The timestamp of the first message that will be delivered by this Consumer
stream_sequence float: The Stream Sequence that will be the first message delivered by this Consumer

durableName String: The durable name of the Consumer
streamId String: The name of the Stream that this consumer consumes
ackPolicy String: The delivery acknowledgement policy to apply to the Consumer
ackWait Number: Number of seconds to wait for acknowledgement
backoffs List<Number>: List of durations in Go format that represents a retry time scale for NaK'd messages. A list of durations in seconds.
consumerId String
deliverAll Boolean: Starts at the first available message in the Stream
deliverLast Boolean: Starts at the latest available message in the Stream
deliverLastPerSubject Boolean: Starts with the last message for each subject matched by filter
deliverNew Boolean: Starts with the next available message in the Stream
deliveryGroup String: When set Push consumers will only deliver messages to subscriptions with this group set
deliverySubject String: The subject where a Push-based consumer will deliver messages
description String: Contains additional information about this consumer
filterSubject String: Only receive a subset of messages from the Stream based on the subject they entered the Stream on
filterSubjects List<String>: Only receive a subset of messages from the stream baseed on the subjects they entered the Streeam on, exlusive to filter_subject and works with nats-server v2.10 or better
flowControl Boolean: Enable flow control for push consumers
headersOnly Boolean: When true no message bodies will be delivered only headers
heartbeat Number: Enable heartbeat messages for push consumers, duration specified in seconds
inactiveThreshold Number: Removes the consumer after a idle period, specified as a duration in seconds
maxAckPending Number: Maximum pending Acks before consumers are paused
maxBatch Number: Limits Pull Batch sizes to this maximum
maxBytes Number: The maximum bytes value that maybe set when dong a pull on a Pull Consumer
maxDelivery Number: Maximum deliveries to attempt for each message
maxExpires Number: Limits the Pull Expires duration to this maximum in seconds
maxWaiting Number: The number of pulls that can be outstanding on a pull consumer, pulls received after this is reached are ignored
memory Boolean: Force the consumer state to be kept in memory rather than inherit the setting from the stream
metadata Map<String>: Free form metadata about the consumer
ratelimit Number: The rate limit for delivering messages to push consumers, expressed in bits per second
replayPolicy String: The rate at which messages will be replayed from the stream
replicas Number: How many replicas of the data to keep in a clustered environment
sampleFreq Number: The percentage of acknowledgements that will be sampled for observability purposes
startTime String: The timestamp of the first message that will be delivered by this Consumer
streamSequence Number: The Stream Sequence that will be the first message delivered by this Consumer

Outputs

All input properties are implicitly available as output properties. Additionally, the Consumer resource produces the following output properties:

Id string: The provider-assigned unique ID for this managed resource.

Id string: The provider-assigned unique ID for this managed resource.

id String: The provider-assigned unique ID for this managed resource.

id string: The provider-assigned unique ID for this managed resource.

id str: The provider-assigned unique ID for this managed resource.

id String: The provider-assigned unique ID for this managed resource.

Look up Existing Consumer Resource

Get an existing Consumer resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: ConsumerState, opts?: CustomResourceOptions): Consumer

@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        ack_policy: Optional[str] = None,
        ack_wait: Optional[float] = None,
        backoffs: Optional[Sequence[float]] = None,
        consumer_id: Optional[str] = None,
        deliver_all: Optional[bool] = None,
        deliver_last: Optional[bool] = None,
        deliver_last_per_subject: Optional[bool] = None,
        deliver_new: Optional[bool] = None,
        delivery_group: Optional[str] = None,
        delivery_subject: Optional[str] = None,
        description: Optional[str] = None,
        durable_name: Optional[str] = None,
        filter_subject: Optional[str] = None,
        filter_subjects: Optional[Sequence[str]] = None,
        flow_control: Optional[bool] = None,
        headers_only: Optional[bool] = None,
        heartbeat: Optional[float] = None,
        inactive_threshold: Optional[float] = None,
        max_ack_pending: Optional[float] = None,
        max_batch: Optional[float] = None,
        max_bytes: Optional[float] = None,
        max_delivery: Optional[float] = None,
        max_expires: Optional[float] = None,
        max_waiting: Optional[float] = None,
        memory: Optional[bool] = None,
        metadata: Optional[Mapping[str, str]] = None,
        ratelimit: Optional[float] = None,
        replay_policy: Optional[str] = None,
        replicas: Optional[float] = None,
        sample_freq: Optional[float] = None,
        start_time: Optional[str] = None,
        stream_id: Optional[str] = None,
        stream_sequence: Optional[float] = None) -> Consumer

func GetConsumer(ctx *Context, name string, id IDInput, state *ConsumerState, opts ...ResourceOption) (*Consumer, error)

public static Consumer Get(string name, Input<string> id, ConsumerState? state, CustomResourceOptions? opts = null)

public static Consumer get(String name, Output<String> id, ConsumerState state, CustomResourceOptions options)

resources:  _:    type: jetstream:Consumer    get:      id: ${id}

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

resource_name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

The following state arguments are supported:

AckPolicy string: The delivery acknowledgement policy to apply to the Consumer
AckWait double: Number of seconds to wait for acknowledgement
Backoffs List<double>: List of durations in Go format that represents a retry time scale for NaK'd messages. A list of durations in seconds.
ConsumerId string
DeliverAll bool: Starts at the first available message in the Stream
DeliverLast bool: Starts at the latest available message in the Stream
DeliverLastPerSubject bool: Starts with the last message for each subject matched by filter
DeliverNew bool: Starts with the next available message in the Stream
DeliveryGroup string: When set Push consumers will only deliver messages to subscriptions with this group set
DeliverySubject string: The subject where a Push-based consumer will deliver messages
Description string: Contains additional information about this consumer
DurableName string: The durable name of the Consumer
FilterSubject string: Only receive a subset of messages from the Stream based on the subject they entered the Stream on
FilterSubjects List<string>: Only receive a subset of messages from the stream baseed on the subjects they entered the Streeam on, exlusive to filter_subject and works with nats-server v2.10 or better
FlowControl bool: Enable flow control for push consumers
HeadersOnly bool: When true no message bodies will be delivered only headers
Heartbeat double: Enable heartbeat messages for push consumers, duration specified in seconds
InactiveThreshold double: Removes the consumer after a idle period, specified as a duration in seconds
MaxAckPending double: Maximum pending Acks before consumers are paused
MaxBatch double: Limits Pull Batch sizes to this maximum
MaxBytes double: The maximum bytes value that maybe set when dong a pull on a Pull Consumer
MaxDelivery double: Maximum deliveries to attempt for each message
MaxExpires double: Limits the Pull Expires duration to this maximum in seconds
MaxWaiting double: The number of pulls that can be outstanding on a pull consumer, pulls received after this is reached are ignored
Memory bool: Force the consumer state to be kept in memory rather than inherit the setting from the stream
Metadata Dictionary<string, string>: Free form metadata about the consumer
Ratelimit double: The rate limit for delivering messages to push consumers, expressed in bits per second
ReplayPolicy string: The rate at which messages will be replayed from the stream
Replicas double: How many replicas of the data to keep in a clustered environment
SampleFreq double: The percentage of acknowledgements that will be sampled for observability purposes
StartTime string: The timestamp of the first message that will be delivered by this Consumer
StreamId string: The name of the Stream that this consumer consumes
StreamSequence double: The Stream Sequence that will be the first message delivered by this Consumer

AckPolicy string: The delivery acknowledgement policy to apply to the Consumer
AckWait float64: Number of seconds to wait for acknowledgement
Backoffs []float64: List of durations in Go format that represents a retry time scale for NaK'd messages. A list of durations in seconds.
ConsumerId string
DeliverAll bool: Starts at the first available message in the Stream
DeliverLast bool: Starts at the latest available message in the Stream
DeliverLastPerSubject bool: Starts with the last message for each subject matched by filter
DeliverNew bool: Starts with the next available message in the Stream
DeliveryGroup string: When set Push consumers will only deliver messages to subscriptions with this group set
DeliverySubject string: The subject where a Push-based consumer will deliver messages
Description string: Contains additional information about this consumer
DurableName string: The durable name of the Consumer
FilterSubject string: Only receive a subset of messages from the Stream based on the subject they entered the Stream on
FilterSubjects []string: Only receive a subset of messages from the stream baseed on the subjects they entered the Streeam on, exlusive to filter_subject and works with nats-server v2.10 or better
FlowControl bool: Enable flow control for push consumers
HeadersOnly bool: When true no message bodies will be delivered only headers
Heartbeat float64: Enable heartbeat messages for push consumers, duration specified in seconds
InactiveThreshold float64: Removes the consumer after a idle period, specified as a duration in seconds
MaxAckPending float64: Maximum pending Acks before consumers are paused
MaxBatch float64: Limits Pull Batch sizes to this maximum
MaxBytes float64: The maximum bytes value that maybe set when dong a pull on a Pull Consumer
MaxDelivery float64: Maximum deliveries to attempt for each message
MaxExpires float64: Limits the Pull Expires duration to this maximum in seconds
MaxWaiting float64: The number of pulls that can be outstanding on a pull consumer, pulls received after this is reached are ignored
Memory bool: Force the consumer state to be kept in memory rather than inherit the setting from the stream
Metadata map[string]string: Free form metadata about the consumer
Ratelimit float64: The rate limit for delivering messages to push consumers, expressed in bits per second
ReplayPolicy string: The rate at which messages will be replayed from the stream
Replicas float64: How many replicas of the data to keep in a clustered environment
SampleFreq float64: The percentage of acknowledgements that will be sampled for observability purposes
StartTime string: The timestamp of the first message that will be delivered by this Consumer
StreamId string: The name of the Stream that this consumer consumes
StreamSequence float64: The Stream Sequence that will be the first message delivered by this Consumer

ackPolicy String: The delivery acknowledgement policy to apply to the Consumer
ackWait Double: Number of seconds to wait for acknowledgement
backoffs List<Double>: List of durations in Go format that represents a retry time scale for NaK'd messages. A list of durations in seconds.
consumerId String
deliverAll Boolean: Starts at the first available message in the Stream
deliverLast Boolean: Starts at the latest available message in the Stream
deliverLastPerSubject Boolean: Starts with the last message for each subject matched by filter
deliverNew Boolean: Starts with the next available message in the Stream
deliveryGroup String: When set Push consumers will only deliver messages to subscriptions with this group set
deliverySubject String: The subject where a Push-based consumer will deliver messages
description String: Contains additional information about this consumer
durableName String: The durable name of the Consumer
filterSubject String: Only receive a subset of messages from the Stream based on the subject they entered the Stream on
filterSubjects List<String>: Only receive a subset of messages from the stream baseed on the subjects they entered the Streeam on, exlusive to filter_subject and works with nats-server v2.10 or better
flowControl Boolean: Enable flow control for push consumers
headersOnly Boolean: When true no message bodies will be delivered only headers
heartbeat Double: Enable heartbeat messages for push consumers, duration specified in seconds
inactiveThreshold Double: Removes the consumer after a idle period, specified as a duration in seconds
maxAckPending Double: Maximum pending Acks before consumers are paused
maxBatch Double: Limits Pull Batch sizes to this maximum
maxBytes Double: The maximum bytes value that maybe set when dong a pull on a Pull Consumer
maxDelivery Double: Maximum deliveries to attempt for each message
maxExpires Double: Limits the Pull Expires duration to this maximum in seconds
maxWaiting Double: The number of pulls that can be outstanding on a pull consumer, pulls received after this is reached are ignored
memory Boolean: Force the consumer state to be kept in memory rather than inherit the setting from the stream
metadata Map<String,String>: Free form metadata about the consumer
ratelimit Double: The rate limit for delivering messages to push consumers, expressed in bits per second
replayPolicy String: The rate at which messages will be replayed from the stream
replicas Double: How many replicas of the data to keep in a clustered environment
sampleFreq Double: The percentage of acknowledgements that will be sampled for observability purposes
startTime String: The timestamp of the first message that will be delivered by this Consumer
streamId String: The name of the Stream that this consumer consumes
streamSequence Double: The Stream Sequence that will be the first message delivered by this Consumer

ackPolicy string: The delivery acknowledgement policy to apply to the Consumer
ackWait number: Number of seconds to wait for acknowledgement
backoffs number[]: List of durations in Go format that represents a retry time scale for NaK'd messages. A list of durations in seconds.
consumerId string
deliverAll boolean: Starts at the first available message in the Stream
deliverLast boolean: Starts at the latest available message in the Stream
deliverLastPerSubject boolean: Starts with the last message for each subject matched by filter
deliverNew boolean: Starts with the next available message in the Stream
deliveryGroup string: When set Push consumers will only deliver messages to subscriptions with this group set
deliverySubject string: The subject where a Push-based consumer will deliver messages
description string: Contains additional information about this consumer
durableName string: The durable name of the Consumer
filterSubject string: Only receive a subset of messages from the Stream based on the subject they entered the Stream on
filterSubjects string[]: Only receive a subset of messages from the stream baseed on the subjects they entered the Streeam on, exlusive to filter_subject and works with nats-server v2.10 or better
flowControl boolean: Enable flow control for push consumers
headersOnly boolean: When true no message bodies will be delivered only headers
heartbeat number: Enable heartbeat messages for push consumers, duration specified in seconds
inactiveThreshold number: Removes the consumer after a idle period, specified as a duration in seconds
maxAckPending number: Maximum pending Acks before consumers are paused
maxBatch number: Limits Pull Batch sizes to this maximum
maxBytes number: The maximum bytes value that maybe set when dong a pull on a Pull Consumer
maxDelivery number: Maximum deliveries to attempt for each message
maxExpires number: Limits the Pull Expires duration to this maximum in seconds
maxWaiting number: The number of pulls that can be outstanding on a pull consumer, pulls received after this is reached are ignored
memory boolean: Force the consumer state to be kept in memory rather than inherit the setting from the stream
metadata {[key: string]: string}: Free form metadata about the consumer
ratelimit number: The rate limit for delivering messages to push consumers, expressed in bits per second
replayPolicy string: The rate at which messages will be replayed from the stream
replicas number: How many replicas of the data to keep in a clustered environment
sampleFreq number: The percentage of acknowledgements that will be sampled for observability purposes
startTime string: The timestamp of the first message that will be delivered by this Consumer
streamId string: The name of the Stream that this consumer consumes
streamSequence number: The Stream Sequence that will be the first message delivered by this Consumer

ack_policy str: The delivery acknowledgement policy to apply to the Consumer
ack_wait float: Number of seconds to wait for acknowledgement
backoffs Sequence[float]: List of durations in Go format that represents a retry time scale for NaK'd messages. A list of durations in seconds.
consumer_id str
deliver_all bool: Starts at the first available message in the Stream
deliver_last bool: Starts at the latest available message in the Stream
deliver_last_per_subject bool: Starts with the last message for each subject matched by filter
deliver_new bool: Starts with the next available message in the Stream
delivery_group str: When set Push consumers will only deliver messages to subscriptions with this group set
delivery_subject str: The subject where a Push-based consumer will deliver messages
description str: Contains additional information about this consumer
durable_name str: The durable name of the Consumer
filter_subject str: Only receive a subset of messages from the Stream based on the subject they entered the Stream on
filter_subjects Sequence[str]: Only receive a subset of messages from the stream baseed on the subjects they entered the Streeam on, exlusive to filter_subject and works with nats-server v2.10 or better
flow_control bool: Enable flow control for push consumers
headers_only bool: When true no message bodies will be delivered only headers
heartbeat float: Enable heartbeat messages for push consumers, duration specified in seconds
inactive_threshold float: Removes the consumer after a idle period, specified as a duration in seconds
max_ack_pending float: Maximum pending Acks before consumers are paused
max_batch float: Limits Pull Batch sizes to this maximum
max_bytes float: The maximum bytes value that maybe set when dong a pull on a Pull Consumer
max_delivery float: Maximum deliveries to attempt for each message
max_expires float: Limits the Pull Expires duration to this maximum in seconds
max_waiting float: The number of pulls that can be outstanding on a pull consumer, pulls received after this is reached are ignored
memory bool: Force the consumer state to be kept in memory rather than inherit the setting from the stream
metadata Mapping[str, str]: Free form metadata about the consumer
ratelimit float: The rate limit for delivering messages to push consumers, expressed in bits per second
replay_policy str: The rate at which messages will be replayed from the stream
replicas float: How many replicas of the data to keep in a clustered environment
sample_freq float: The percentage of acknowledgements that will be sampled for observability purposes
start_time str: The timestamp of the first message that will be delivered by this Consumer
stream_id str: The name of the Stream that this consumer consumes
stream_sequence float: The Stream Sequence that will be the first message delivered by this Consumer

ackPolicy String: The delivery acknowledgement policy to apply to the Consumer
ackWait Number: Number of seconds to wait for acknowledgement
backoffs List<Number>: List of durations in Go format that represents a retry time scale for NaK'd messages. A list of durations in seconds.
consumerId String
deliverAll Boolean: Starts at the first available message in the Stream
deliverLast Boolean: Starts at the latest available message in the Stream
deliverLastPerSubject Boolean: Starts with the last message for each subject matched by filter
deliverNew Boolean: Starts with the next available message in the Stream
deliveryGroup String: When set Push consumers will only deliver messages to subscriptions with this group set
deliverySubject String: The subject where a Push-based consumer will deliver messages
description String: Contains additional information about this consumer
durableName String: The durable name of the Consumer
filterSubject String: Only receive a subset of messages from the Stream based on the subject they entered the Stream on
filterSubjects List<String>: Only receive a subset of messages from the stream baseed on the subjects they entered the Streeam on, exlusive to filter_subject and works with nats-server v2.10 or better
flowControl Boolean: Enable flow control for push consumers
headersOnly Boolean: When true no message bodies will be delivered only headers
heartbeat Number: Enable heartbeat messages for push consumers, duration specified in seconds
inactiveThreshold Number: Removes the consumer after a idle period, specified as a duration in seconds
maxAckPending Number: Maximum pending Acks before consumers are paused
maxBatch Number: Limits Pull Batch sizes to this maximum
maxBytes Number: The maximum bytes value that maybe set when dong a pull on a Pull Consumer
maxDelivery Number: Maximum deliveries to attempt for each message
maxExpires Number: Limits the Pull Expires duration to this maximum in seconds
maxWaiting Number: The number of pulls that can be outstanding on a pull consumer, pulls received after this is reached are ignored
memory Boolean: Force the consumer state to be kept in memory rather than inherit the setting from the stream
metadata Map<String>: Free form metadata about the consumer
ratelimit Number: The rate limit for delivering messages to push consumers, expressed in bits per second
replayPolicy String: The rate at which messages will be replayed from the stream
replicas Number: How many replicas of the data to keep in a clustered environment
sampleFreq Number: The percentage of acknowledgements that will be sampled for observability purposes
startTime String: The timestamp of the first message that will be delivered by this Consumer
streamId String: The name of the Stream that this consumer consumes
streamSequence Number: The Stream Sequence that will be the first message delivered by this Consumer

Package Details

Repository: jetstream nats-io/terraform-provider-jetstream
License
Notes: This Pulumi package is based on the jetstream Terraform Provider.

jetstream 0.2.0 published on Monday, Apr 14, 2025 by nats-io

nats-io/terraform-provider-jetstream

jetstream.Consumer

On this page

On this page

Example Usage

Attribute Reference

Create Consumer Resource

Constructor syntax

Parameters

Constructor example

Consumer Resource Properties

Inputs

Outputs

Look up Existing Consumer Resource

Package Details

On this page

On this page