alicloud.nas.getLogAnalyses

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

const defaultFileSystem = new alicloud.nas.FileSystem("default", {
    protocolType: "NFS",
    storageType: "Capacity",
});
const defaultLogAnalysis = new alicloud.nas.LogAnalysis("default", {fileSystemId: defaultFileSystem.id});
const _default = alicloud.nas.getLogAnalysesOutput({
    ids: [defaultLogAnalysis.id],
});
export const alicloudNasLogAnalysisExampleId = _default.apply(_default => _default.analyses?.[0]?.id);

import pulumi
import pulumi_alicloud as alicloud

default_file_system = alicloud.nas.FileSystem("default",
    protocol_type="NFS",
    storage_type="Capacity")
default_log_analysis = alicloud.nas.LogAnalysis("default", file_system_id=default_file_system.id)
default = alicloud.nas.get_log_analyses_output(ids=[default_log_analysis.id])
pulumi.export("alicloudNasLogAnalysisExampleId", default.analyses[0].id)

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/nas"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultFileSystem, err := nas.NewFileSystem(ctx, "default", &nas.FileSystemArgs{
			ProtocolType: pulumi.String("NFS"),
			StorageType:  pulumi.String("Capacity"),
		})
		if err != nil {
			return err
		}
		defaultLogAnalysis, err := nas.NewLogAnalysis(ctx, "default", &nas.LogAnalysisArgs{
			FileSystemId: defaultFileSystem.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		_default := nas.GetLogAnalysesOutput(ctx, nas.GetLogAnalysesOutputArgs{
			Ids: pulumi.StringArray{
				defaultLogAnalysis.ID().ToIDOutput().ToStringOutput(),
			},
		}, nil)
		ctx.Export("alicloudNasLogAnalysisExampleId", _default.ApplyT(func(_default nas.GetLogAnalysesResult) (*string, error) {
			return _default.Analyses[0].Id, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var defaultFileSystem = new AliCloud.Nas.FileSystem("default", new()
    {
        ProtocolType = "NFS",
        StorageType = "Capacity",
    });

    var defaultLogAnalysis = new AliCloud.Nas.LogAnalysis("default", new()
    {
        FileSystemId = defaultFileSystem.Id,
    });

    var @default = AliCloud.Nas.GetLogAnalyses.Invoke(new()
    {
        Ids = new[]
        {
            defaultLogAnalysis.Id,
        },
    });

    return new Dictionary<string, object?>
    {
        ["alicloudNasLogAnalysisExampleId"] = @default.Apply(@default => @default.Apply(getLogAnalysesResult => getLogAnalysesResult.Analyses[0]?.Id)),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.nas.FileSystem;
import com.pulumi.alicloud.nas.FileSystemArgs;
import com.pulumi.alicloud.nas.LogAnalysis;
import com.pulumi.alicloud.nas.LogAnalysisArgs;
import com.pulumi.alicloud.nas.NasFunctions;
import com.pulumi.alicloud.nas.inputs.GetLogAnalysesArgs;
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) {
        var defaultFileSystem = new FileSystem("defaultFileSystem", FileSystemArgs.builder()
            .protocolType("NFS")
            .storageType("Capacity")
            .build());

        var defaultLogAnalysis = new LogAnalysis("defaultLogAnalysis", LogAnalysisArgs.builder()
            .fileSystemId(defaultFileSystem.id())
            .build());

        final var default = NasFunctions.getLogAnalyses(GetLogAnalysesArgs.builder()
            .ids(defaultLogAnalysis.id())
            .build());

        ctx.export("alicloudNasLogAnalysisExampleId", default_.applyValue(_default_ -> _default_.analyses()[0].id()));
    }
}

resources:
  defaultFileSystem:
    type: alicloud:nas:FileSystem
    name: default
    properties:
      protocolType: NFS
      storageType: Capacity
  defaultLogAnalysis:
    type: alicloud:nas:LogAnalysis
    name: default
    properties:
      fileSystemId: ${defaultFileSystem.id}
variables:
  default:
    fn::invoke:
      function: alicloud:nas:getLogAnalyses
      arguments:
        ids:
          - ${defaultLogAnalysis.id}
outputs:
  alicloudNasLogAnalysisExampleId: ${default.analyses[0].id}

pulumi {
  required_providers {
    alicloud = {
      source = "pulumi/alicloud"
    }
  }
}

data "alicloud_nas_getloganalyses" "default" {
  ids = [alicloud_nas_loganalysis.default.id]
}

resource "alicloud_nas_filesystem" "default" {
  protocol_type = "NFS"
  storage_type  = "Capacity"
}
resource "alicloud_nas_loganalysis" "default" {
  file_system_id = alicloud_nas_filesystem.default.id
}
output "alicloudNasLogAnalysisExampleId" {
  value = data.alicloud_nas_getloganalyses.default.analyses[0].id
}

function getLogAnalyses(args: GetLogAnalysesArgs, opts?: InvokeOptions): Promise<GetLogAnalysesResult>
function getLogAnalysesOutput(args: GetLogAnalysesOutputArgs, opts?: InvokeOutputOptions): Output<GetLogAnalysesResult>

def get_log_analyses(file_system_type: Optional[str] = None,
                     ids: Optional[Sequence[str]] = None,
                     output_file: Optional[str] = None,
                     opts: Optional[InvokeOptions] = None) -> GetLogAnalysesResult
def get_log_analyses_output(file_system_type: pulumi.Input[Optional[str]] = None,
                     ids: pulumi.Input[Optional[Sequence[pulumi.Input[str]]]] = None,
                     output_file: pulumi.Input[Optional[str]] = None,
                     opts: Optional[InvokeOutputOptions] = None) -> Output[GetLogAnalysesResult]

func GetLogAnalyses(ctx *Context, args *GetLogAnalysesArgs, opts ...InvokeOption) (*GetLogAnalysesResult, error)
func GetLogAnalysesOutput(ctx *Context, args *GetLogAnalysesOutputArgs, opts ...InvokeOption) GetLogAnalysesResultOutput

public static class GetLogAnalyses 
{
    public static Task<GetLogAnalysesResult> InvokeAsync(GetLogAnalysesArgs args, InvokeOptions? opts = null)
    public static Output<GetLogAnalysesResult> Invoke(GetLogAnalysesInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetLogAnalysesResult> Invoke(GetLogAnalysesInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetLogAnalysesResult> getLogAnalyses(GetLogAnalysesArgs args, InvokeOptions options)
public static Output<GetLogAnalysesResult> getLogAnalyses(GetLogAnalysesArgs args, InvokeOptions options)
public static Output<GetLogAnalysesResult> getLogAnalyses(GetLogAnalysesArgs args, InvokeOutputOptions options)

fn::invoke:
  function: alicloud:nas/getLogAnalyses:getLogAnalyses
  arguments:
    # arguments dictionary

data "alicloud_nas_get_log_analyses" "name" {
    # arguments
}