alicloud.cr.getArtifactLifecycleRules

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

const config = new pulumi.Config();
const name = config.get("name") || "terraform-example";
const defaultRegistryEnterpriseInstance = new alicloud.cr.RegistryEnterpriseInstance("default", {
    defaultOssBucket: "true",
    instanceName: name,
    renewalStatus: "ManualRenewal",
    imageScanner: "DISABLE",
    period: 1,
    paymentType: "Subscription",
    instanceType: "Economy",
});
const defaultRegistryEnterpriseNamespace = new alicloud.cs.RegistryEnterpriseNamespace("default", {
    instanceId: defaultRegistryEnterpriseInstance.id,
    name: name,
    autoCreate: false,
    defaultVisibility: "PRIVATE",
});
const defaultRegistryEnterpriseRepo = new alicloud.cs.RegistryEnterpriseRepo("default", {
    instanceId: defaultRegistryEnterpriseInstance.id,
    namespace: defaultRegistryEnterpriseNamespace.name,
    name: name,
    repoType: "PRIVATE",
    summary: "example repository for lifecycle rule",
});
const defaultArtifactLifecycleRule = new alicloud.cr.ArtifactLifecycleRule("default", {
    auto: true,
    namespaceName: defaultRegistryEnterpriseNamespace.name,
    retentionTagCount: 30,
    scheduleTime: "WEEK",
    scope: "REPO",
    instanceId: defaultRegistryEnterpriseInstance.id,
    tagRegexp: ".*",
    repoName: defaultRegistryEnterpriseRepo.name,
});
const _default = alicloud.cr.getArtifactLifecycleRulesOutput({
    ids: [defaultArtifactLifecycleRule.id],
    instanceId: defaultRegistryEnterpriseInstance.id,
});
export const alicloudCrArtifactLifecycleRuleExampleId = _default.apply(_default => _default.rules?.[0]?.id);

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
default_registry_enterprise_instance = alicloud.cr.RegistryEnterpriseInstance("default",
    default_oss_bucket="true",
    instance_name=name,
    renewal_status="ManualRenewal",
    image_scanner="DISABLE",
    period=1,
    payment_type="Subscription",
    instance_type="Economy")
default_registry_enterprise_namespace = alicloud.cs.RegistryEnterpriseNamespace("default",
    instance_id=default_registry_enterprise_instance.id,
    name=name,
    auto_create=False,
    default_visibility="PRIVATE")
default_registry_enterprise_repo = alicloud.cs.RegistryEnterpriseRepo("default",
    instance_id=default_registry_enterprise_instance.id,
    namespace=default_registry_enterprise_namespace.name,
    name=name,
    repo_type="PRIVATE",
    summary="example repository for lifecycle rule")
default_artifact_lifecycle_rule = alicloud.cr.ArtifactLifecycleRule("default",
    auto=True,
    namespace_name=default_registry_enterprise_namespace.name,
    retention_tag_count=30,
    schedule_time="WEEK",
    scope="REPO",
    instance_id=default_registry_enterprise_instance.id,
    tag_regexp=".*",
    repo_name=default_registry_enterprise_repo.name)
default = alicloud.cr.get_artifact_lifecycle_rules_output(ids=[default_artifact_lifecycle_rule.id],
    instance_id=default_registry_enterprise_instance.id)
pulumi.export("alicloudCrArtifactLifecycleRuleExampleId", default.rules[0].id)

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/cr"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/cs"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		name := "terraform-example"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		defaultRegistryEnterpriseInstance, err := cr.NewRegistryEnterpriseInstance(ctx, "default", &cr.RegistryEnterpriseInstanceArgs{
			DefaultOssBucket: pulumi.String("true"),
			InstanceName:     pulumi.String(name),
			RenewalStatus:    pulumi.String("ManualRenewal"),
			ImageScanner:     pulumi.String("DISABLE"),
			Period:           pulumi.Int(1),
			PaymentType:      pulumi.String("Subscription"),
			InstanceType:     pulumi.String("Economy"),
		})
		if err != nil {
			return err
		}
		defaultRegistryEnterpriseNamespace, err := cs.NewRegistryEnterpriseNamespace(ctx, "default", &cs.RegistryEnterpriseNamespaceArgs{
			InstanceId:        defaultRegistryEnterpriseInstance.ID(),
			Name:              pulumi.String(name),
			AutoCreate:        pulumi.Bool(false),
			DefaultVisibility: pulumi.String("PRIVATE"),
		})
		if err != nil {
			return err
		}
		defaultRegistryEnterpriseRepo, err := cs.NewRegistryEnterpriseRepo(ctx, "default", &cs.RegistryEnterpriseRepoArgs{
			InstanceId: defaultRegistryEnterpriseInstance.ID(),
			Namespace:  defaultRegistryEnterpriseNamespace.Name,
			Name:       pulumi.String(name),
			RepoType:   pulumi.String("PRIVATE"),
			Summary:    pulumi.String("example repository for lifecycle rule"),
		})
		if err != nil {
			return err
		}
		defaultArtifactLifecycleRule, err := cr.NewArtifactLifecycleRule(ctx, "default", &cr.ArtifactLifecycleRuleArgs{
			Auto:              pulumi.Bool(true),
			NamespaceName:     defaultRegistryEnterpriseNamespace.Name,
			RetentionTagCount: pulumi.Int(30),
			ScheduleTime:      pulumi.String("WEEK"),
			Scope:             pulumi.String("REPO"),
			InstanceId:        defaultRegistryEnterpriseInstance.ID(),
			TagRegexp:         pulumi.String(".*"),
			RepoName:          defaultRegistryEnterpriseRepo.Name,
		})
		if err != nil {
			return err
		}
		_default := cr.GetArtifactLifecycleRulesOutput(ctx, cr.GetArtifactLifecycleRulesOutputArgs{
			Ids: pulumi.StringArray{
				defaultArtifactLifecycleRule.ID(),
			},
			InstanceId: defaultRegistryEnterpriseInstance.ID(),
		}, nil)
		ctx.Export("alicloudCrArtifactLifecycleRuleExampleId", _default.ApplyT(func(_default cr.GetArtifactLifecycleRulesResult) (*string, error) {
			return _default.Rules[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 config = new Config();
    var name = config.Get("name") ?? "terraform-example";
    var defaultRegistryEnterpriseInstance = new AliCloud.CR.RegistryEnterpriseInstance("default", new()
    {
        DefaultOssBucket = "true",
        InstanceName = name,
        RenewalStatus = "ManualRenewal",
        ImageScanner = "DISABLE",
        Period = 1,
        PaymentType = "Subscription",
        InstanceType = "Economy",
    });

    var defaultRegistryEnterpriseNamespace = new AliCloud.CS.RegistryEnterpriseNamespace("default", new()
    {
        InstanceId = defaultRegistryEnterpriseInstance.Id,
        Name = name,
        AutoCreate = false,
        DefaultVisibility = "PRIVATE",
    });

    var defaultRegistryEnterpriseRepo = new AliCloud.CS.RegistryEnterpriseRepo("default", new()
    {
        InstanceId = defaultRegistryEnterpriseInstance.Id,
        Namespace = defaultRegistryEnterpriseNamespace.Name,
        Name = name,
        RepoType = "PRIVATE",
        Summary = "example repository for lifecycle rule",
    });

    var defaultArtifactLifecycleRule = new AliCloud.CR.ArtifactLifecycleRule("default", new()
    {
        Auto = true,
        NamespaceName = defaultRegistryEnterpriseNamespace.Name,
        RetentionTagCount = 30,
        ScheduleTime = "WEEK",
        Scope = "REPO",
        InstanceId = defaultRegistryEnterpriseInstance.Id,
        TagRegexp = ".*",
        RepoName = defaultRegistryEnterpriseRepo.Name,
    });

    var @default = AliCloud.CR.GetArtifactLifecycleRules.Invoke(new()
    {
        Ids = new[]
        {
            defaultArtifactLifecycleRule.Id,
        },
        InstanceId = defaultRegistryEnterpriseInstance.Id,
    });

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

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.cr.RegistryEnterpriseInstance;
import com.pulumi.alicloud.cr.RegistryEnterpriseInstanceArgs;
import com.pulumi.alicloud.cs.RegistryEnterpriseNamespace;
import com.pulumi.alicloud.cs.RegistryEnterpriseNamespaceArgs;
import com.pulumi.alicloud.cs.RegistryEnterpriseRepo;
import com.pulumi.alicloud.cs.RegistryEnterpriseRepoArgs;
import com.pulumi.alicloud.cr.ArtifactLifecycleRule;
import com.pulumi.alicloud.cr.ArtifactLifecycleRuleArgs;
import com.pulumi.alicloud.cr.CrFunctions;
import com.pulumi.alicloud.cr.inputs.GetArtifactLifecycleRulesArgs;
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 config = ctx.config();
        final var name = config.get("name").orElse("terraform-example");
        var defaultRegistryEnterpriseInstance = new RegistryEnterpriseInstance("defaultRegistryEnterpriseInstance", RegistryEnterpriseInstanceArgs.builder()
            .defaultOssBucket("true")
            .instanceName(name)
            .renewalStatus("ManualRenewal")
            .imageScanner("DISABLE")
            .period(1)
            .paymentType("Subscription")
            .instanceType("Economy")
            .build());

        var defaultRegistryEnterpriseNamespace = new RegistryEnterpriseNamespace("defaultRegistryEnterpriseNamespace", RegistryEnterpriseNamespaceArgs.builder()
            .instanceId(defaultRegistryEnterpriseInstance.id())
            .name(name)
            .autoCreate(false)
            .defaultVisibility("PRIVATE")
            .build());

        var defaultRegistryEnterpriseRepo = new RegistryEnterpriseRepo("defaultRegistryEnterpriseRepo", RegistryEnterpriseRepoArgs.builder()
            .instanceId(defaultRegistryEnterpriseInstance.id())
            .namespace(defaultRegistryEnterpriseNamespace.name())
            .name(name)
            .repoType("PRIVATE")
            .summary("example repository for lifecycle rule")
            .build());

        var defaultArtifactLifecycleRule = new ArtifactLifecycleRule("defaultArtifactLifecycleRule", ArtifactLifecycleRuleArgs.builder()
            .auto(true)
            .namespaceName(defaultRegistryEnterpriseNamespace.name())
            .retentionTagCount(30)
            .scheduleTime("WEEK")
            .scope("REPO")
            .instanceId(defaultRegistryEnterpriseInstance.id())
            .tagRegexp(".*")
            .repoName(defaultRegistryEnterpriseRepo.name())
            .build());

        final var default = CrFunctions.getArtifactLifecycleRules(GetArtifactLifecycleRulesArgs.builder()
            .ids(defaultArtifactLifecycleRule.id())
            .instanceId(defaultRegistryEnterpriseInstance.id())
            .build());

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

configuration:
  name:
    type: string
    default: terraform-example
resources:
  defaultRegistryEnterpriseInstance:
    type: alicloud:cr:RegistryEnterpriseInstance
    name: default
    properties:
      defaultOssBucket: 'true'
      instanceName: ${name}
      renewalStatus: ManualRenewal
      imageScanner: DISABLE
      period: '1'
      paymentType: Subscription
      instanceType: Economy
  defaultRegistryEnterpriseNamespace:
    type: alicloud:cs:RegistryEnterpriseNamespace
    name: default
    properties:
      instanceId: ${defaultRegistryEnterpriseInstance.id}
      name: ${name}
      autoCreate: false
      defaultVisibility: PRIVATE
  defaultRegistryEnterpriseRepo:
    type: alicloud:cs:RegistryEnterpriseRepo
    name: default
    properties:
      instanceId: ${defaultRegistryEnterpriseInstance.id}
      namespace: ${defaultRegistryEnterpriseNamespace.name}
      name: ${name}
      repoType: PRIVATE
      summary: example repository for lifecycle rule
  defaultArtifactLifecycleRule:
    type: alicloud:cr:ArtifactLifecycleRule
    name: default
    properties:
      auto: true
      namespaceName: ${defaultRegistryEnterpriseNamespace.name}
      retentionTagCount: '30'
      scheduleTime: WEEK
      scope: REPO
      instanceId: ${defaultRegistryEnterpriseInstance.id}
      tagRegexp: .*
      repoName: ${defaultRegistryEnterpriseRepo.name}
variables:
  default:
    fn::invoke:
      function: alicloud:cr:getArtifactLifecycleRules
      arguments:
        ids:
          - ${defaultArtifactLifecycleRule.id}
        instanceId: ${defaultRegistryEnterpriseInstance.id}
outputs:
  alicloudCrArtifactLifecycleRuleExampleId: ${default.rules[0].id}

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

data "alicloud_cr_getartifactlifecyclerules" "default" {
  ids         = [alicloud_cr_artifactlifecyclerule.default.id]
  instance_id = alicloud_cr_registryenterpriseinstance.default.id
}

resource "alicloud_cr_registryenterpriseinstance" "default" {
  default_oss_bucket = "true"
  instance_name      = var.name
  renewal_status     = "ManualRenewal"
  image_scanner      = "DISABLE"
  period             = "1"
  payment_type       = "Subscription"
  instance_type      = "Economy"
}
resource "alicloud_cs_registryenterprisenamespace" "default" {
  instance_id        = alicloud_cr_registryenterpriseinstance.default.id
  name               = var.name
  auto_create        = false
  default_visibility = "PRIVATE"
}
resource "alicloud_cs_registryenterpriserepo" "default" {
  instance_id = alicloud_cr_registryenterpriseinstance.default.id
  namespace   = alicloud_cs_registryenterprisenamespace.default.name
  name        = var.name
  repo_type   = "PRIVATE"
  summary     = "example repository for lifecycle rule"
}
resource "alicloud_cr_artifactlifecyclerule" "default" {
  auto                = true
  namespace_name      = alicloud_cs_registryenterprisenamespace.default.name
  retention_tag_count = "30"
  schedule_time       = "WEEK"
  scope               = "REPO"
  instance_id         = alicloud_cr_registryenterpriseinstance.default.id
  tag_regexp          = ".*"
  repo_name           = alicloud_cs_registryenterpriserepo.default.name
}
variable "name" {
  type    = string
  default = "terraform-example"
}
output "alicloudCrArtifactLifecycleRuleExampleId" {
  value = data.alicloud_cr_getartifactlifecyclerules.default.rules[0].id
}

function getArtifactLifecycleRules(args: GetArtifactLifecycleRulesArgs, opts?: InvokeOptions): Promise<GetArtifactLifecycleRulesResult>
function getArtifactLifecycleRulesOutput(args: GetArtifactLifecycleRulesOutputArgs, opts?: InvokeOptions): Output<GetArtifactLifecycleRulesResult>

def get_artifact_lifecycle_rules(ids: Optional[Sequence[str]] = None,
                                 instance_id: Optional[str] = None,
                                 output_file: Optional[str] = None,
                                 opts: Optional[InvokeOptions] = None) -> GetArtifactLifecycleRulesResult
def get_artifact_lifecycle_rules_output(ids: pulumi.Input[Optional[Sequence[pulumi.Input[str]]]] = None,
                                 instance_id: pulumi.Input[Optional[str]] = None,
                                 output_file: pulumi.Input[Optional[str]] = None,
                                 opts: Optional[InvokeOptions] = None) -> Output[GetArtifactLifecycleRulesResult]

func GetArtifactLifecycleRules(ctx *Context, args *GetArtifactLifecycleRulesArgs, opts ...InvokeOption) (*GetArtifactLifecycleRulesResult, error)
func GetArtifactLifecycleRulesOutput(ctx *Context, args *GetArtifactLifecycleRulesOutputArgs, opts ...InvokeOption) GetArtifactLifecycleRulesResultOutput

public static class GetArtifactLifecycleRules 
{
    public static Task<GetArtifactLifecycleRulesResult> InvokeAsync(GetArtifactLifecycleRulesArgs args, InvokeOptions? opts = null)
    public static Output<GetArtifactLifecycleRulesResult> Invoke(GetArtifactLifecycleRulesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetArtifactLifecycleRulesResult> getArtifactLifecycleRules(GetArtifactLifecycleRulesArgs args, InvokeOptions options)
public static Output<GetArtifactLifecycleRulesResult> getArtifactLifecycleRules(GetArtifactLifecycleRulesArgs args, InvokeOptions options)

fn::invoke:
  function: alicloud:cr/getArtifactLifecycleRules:getArtifactLifecycleRules
  arguments:
    # arguments dictionary

data "alicloud_cr_get_artifact_lifecycle_rules" "name" {
    # arguments
}