elasticstack.ElasticsearchDataStream

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

// Create an ILM policy for our data stream
const myIlm = new elasticstack.ElasticsearchIndexLifecycle("myIlm", {
    hot: {
        minAge: "1h",
        setPriority: {
            priority: 10,
        },
        rollover: {
            maxAge: "1d",
        },
        readonly: {},
    },
    "delete": {
        minAge: "2d",
        "delete": {},
    },
});
// First we must have a index template created
const myDataStreamTemplate = new elasticstack.ElasticsearchIndexTemplate("myDataStreamTemplate", {
    indexPatterns: ["my-stream*"],
    template: {
        settings: pulumi.jsonStringify({
            "lifecycle.name": myIlm.name,
        }),
    },
    dataStream: {},
});
// and now we can create data stream based on the index template
const myDataStream = new elasticstack.ElasticsearchDataStream("myDataStream", {}, {
    dependsOn: [myDataStreamTemplate],
});

import pulumi
import json
import pulumi_elasticstack as elasticstack

# Create an ILM policy for our data stream
my_ilm = elasticstack.ElasticsearchIndexLifecycle("myIlm",
    hot={
        "min_age": "1h",
        "set_priority": {
            "priority": 10,
        },
        "rollover": {
            "max_age": "1d",
        },
        "readonly": {},
    },
    delete={
        "min_age": "2d",
        "delete": {},
    })
# First we must have a index template created
my_data_stream_template = elasticstack.ElasticsearchIndexTemplate("myDataStreamTemplate",
    index_patterns=["my-stream*"],
    template={
        "settings": pulumi.Output.json_dumps({
            "lifecycle.name": my_ilm.name,
        }),
    },
    data_stream={})
# and now we can create data stream based on the index template
my_data_stream = elasticstack.ElasticsearchDataStream("myDataStream", opts = pulumi.ResourceOptions(depends_on=[my_data_stream_template]))

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/elasticstack/elasticstack"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create an ILM policy for our data stream
		myIlm, err := elasticstack.NewElasticsearchIndexLifecycle(ctx, "myIlm", &elasticstack.ElasticsearchIndexLifecycleArgs{
			Hot: &elasticstack.ElasticsearchIndexLifecycleHotArgs{
				MinAge: pulumi.String("1h"),
				SetPriority: &elasticstack.ElasticsearchIndexLifecycleHotSetPriorityArgs{
					Priority: pulumi.Float64(10),
				},
				Rollover: &elasticstack.ElasticsearchIndexLifecycleHotRolloverArgs{
					MaxAge: pulumi.String("1d"),
				},
				Readonly: &elasticstack.ElasticsearchIndexLifecycleHotReadonlyArgs{},
			},
			Delete: &elasticstack.ElasticsearchIndexLifecycleDeleteArgs{
				MinAge: pulumi.String("2d"),
				Delete: &elasticstack.ElasticsearchIndexLifecycleDeleteDeleteArgs{},
			},
		})
		if err != nil {
			return err
		}
		// First we must have a index template created
		myDataStreamTemplate, err := elasticstack.NewElasticsearchIndexTemplate(ctx, "myDataStreamTemplate", &elasticstack.ElasticsearchIndexTemplateArgs{
			IndexPatterns: pulumi.StringArray{
				pulumi.String("my-stream*"),
			},
			Template: &elasticstack.ElasticsearchIndexTemplateTemplateArgs{
				Settings: myIlm.Name.ApplyT(func(name string) (pulumi.String, error) {
					var _zero pulumi.String
					tmpJSON0, err := json.Marshal(map[string]interface{}{
						"lifecycle.name": name,
					})
					if err != nil {
						return _zero, err
					}
					json0 := string(tmpJSON0)
					return pulumi.String(json0), nil
				}).(pulumi.StringOutput),
			},
			DataStream: &elasticstack.ElasticsearchIndexTemplateDataStreamArgs{},
		})
		if err != nil {
			return err
		}
		// and now we can create data stream based on the index template
		_, err = elasticstack.NewElasticsearchDataStream(ctx, "myDataStream", nil, pulumi.DependsOn([]pulumi.Resource{
			myDataStreamTemplate,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Elasticstack = Pulumi.Elasticstack;

return await Deployment.RunAsync(() => 
{
    // Create an ILM policy for our data stream
    var myIlm = new Elasticstack.ElasticsearchIndexLifecycle("myIlm", new()
    {
        Hot = new Elasticstack.Inputs.ElasticsearchIndexLifecycleHotArgs
        {
            MinAge = "1h",
            SetPriority = new Elasticstack.Inputs.ElasticsearchIndexLifecycleHotSetPriorityArgs
            {
                Priority = 10,
            },
            Rollover = new Elasticstack.Inputs.ElasticsearchIndexLifecycleHotRolloverArgs
            {
                MaxAge = "1d",
            },
            Readonly = null,
        },
        Delete = new Elasticstack.Inputs.ElasticsearchIndexLifecycleDeleteArgs
        {
            MinAge = "2d",
            Delete = null,
        },
    });

    // First we must have a index template created
    var myDataStreamTemplate = new Elasticstack.ElasticsearchIndexTemplate("myDataStreamTemplate", new()
    {
        IndexPatterns = new[]
        {
            "my-stream*",
        },
        Template = new Elasticstack.Inputs.ElasticsearchIndexTemplateTemplateArgs
        {
            Settings = Output.JsonSerialize(Output.Create(new Dictionary<string, object?>
            {
                ["lifecycle.name"] = myIlm.Name,
            })),
        },
        DataStream = null,
    });

    // and now we can create data stream based on the index template
    var myDataStream = new Elasticstack.ElasticsearchDataStream("myDataStream", new()
    {
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            myDataStreamTemplate,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.elasticstack.ElasticsearchIndexLifecycle;
import com.pulumi.elasticstack.ElasticsearchIndexLifecycleArgs;
import com.pulumi.elasticstack.inputs.ElasticsearchIndexLifecycleHotArgs;
import com.pulumi.elasticstack.inputs.ElasticsearchIndexLifecycleHotSetPriorityArgs;
import com.pulumi.elasticstack.inputs.ElasticsearchIndexLifecycleHotRolloverArgs;
import com.pulumi.elasticstack.inputs.ElasticsearchIndexLifecycleHotReadonlyArgs;
import com.pulumi.elasticstack.inputs.ElasticsearchIndexLifecycleDeleteArgs;
import com.pulumi.elasticstack.inputs.ElasticsearchIndexLifecycleDeleteDeleteArgs;
import com.pulumi.elasticstack.ElasticsearchIndexTemplate;
import com.pulumi.elasticstack.ElasticsearchIndexTemplateArgs;
import com.pulumi.elasticstack.inputs.ElasticsearchIndexTemplateTemplateArgs;
import com.pulumi.elasticstack.inputs.ElasticsearchIndexTemplateDataStreamArgs;
import com.pulumi.elasticstack.ElasticsearchDataStream;
import com.pulumi.elasticstack.ElasticsearchDataStreamArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import com.pulumi.resources.CustomResourceOptions;
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) {
        // Create an ILM policy for our data stream
        var myIlm = new ElasticsearchIndexLifecycle("myIlm", ElasticsearchIndexLifecycleArgs.builder()
            .hot(ElasticsearchIndexLifecycleHotArgs.builder()
                .minAge("1h")
                .setPriority(ElasticsearchIndexLifecycleHotSetPriorityArgs.builder()
                    .priority(10)
                    .build())
                .rollover(ElasticsearchIndexLifecycleHotRolloverArgs.builder()
                    .maxAge("1d")
                    .build())
                .readonly()
                .build())
            .delete(ElasticsearchIndexLifecycleDeleteArgs.builder()
                .minAge("2d")
                .delete()
                .build())
            .build());

        // First we must have a index template created
        var myDataStreamTemplate = new ElasticsearchIndexTemplate("myDataStreamTemplate", ElasticsearchIndexTemplateArgs.builder()
            .indexPatterns("my-stream*")
            .template(ElasticsearchIndexTemplateTemplateArgs.builder()
                .settings(myIlm.name().applyValue(name -> serializeJson(
                    jsonObject(
                        jsonProperty("lifecycle.name", name)
                    ))))
                .build())
            .dataStream()
            .build());

        // and now we can create data stream based on the index template
        var myDataStream = new ElasticsearchDataStream("myDataStream", ElasticsearchDataStreamArgs.Empty, CustomResourceOptions.builder()
            .dependsOn(myDataStreamTemplate)
            .build());

    }
}

resources:
  # Create an ILM policy for our data stream
  myIlm:
    type: elasticstack:ElasticsearchIndexLifecycle
    properties:
      hot:
        minAge: 1h
        setPriority:
          priority: 10
        rollover:
          maxAge: 1d
        readonly: {}
      delete:
        minAge: 2d
        delete: {}
  # First we must have a index template created
  myDataStreamTemplate:
    type: elasticstack:ElasticsearchIndexTemplate
    properties:
      indexPatterns:
        - my-stream*
      template:
        settings:
          fn::toJSON:
            lifecycle.name: ${myIlm.name}
      dataStream: {}
  # and now we can create data stream based on the index template
  myDataStream:
    type: elasticstack:ElasticsearchDataStream
    options:
      dependsOn:
        - ${myDataStreamTemplate}

var elasticsearchDataStreamResource = new Elasticstack.ElasticsearchDataStream("elasticsearchDataStreamResource", new()
{
    Name = "string",
});

example, err := elasticstack.NewElasticsearchDataStream(ctx, "elasticsearchDataStreamResource", &elasticstack.ElasticsearchDataStreamArgs{
	Name: pulumi.String("string"),
})

var elasticsearchDataStreamResource = new ElasticsearchDataStream("elasticsearchDataStreamResource", ElasticsearchDataStreamArgs.builder()
    .name("string")
    .build());

elasticsearch_data_stream_resource = elasticstack.ElasticsearchDataStream("elasticsearchDataStreamResource", name="string")

const elasticsearchDataStreamResource = new elasticstack.ElasticsearchDataStream("elasticsearchDataStreamResource", {name: "string"});

type: elasticstack:ElasticsearchDataStream
properties:
    name: string