From a3430f1f3eaea4feada691e04fabb2ee16a329de Mon Sep 17 00:00:00 2001 From: Rupam-It Date: Wed, 26 Aug 2026 13:46:55 +0530 Subject: [PATCH 1/6] sync proto with service Signed-off-by: Rupam-It --- internal/gen/api/v1/profiling.pb.go | 4 ++-- internal/proto/api/v1/profiling.proto | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/internal/gen/api/v1/profiling.pb.go b/internal/gen/api/v1/profiling.pb.go index 01fcf07..4f3b448 100644 --- a/internal/gen/api/v1/profiling.pb.go +++ b/internal/gen/api/v1/profiling.pb.go @@ -136,8 +136,8 @@ type GetWorkloadProfilesRequest struct { Workloads []*ProfilingWorkloadKey `protobuf:"bytes,3,rep,name=workloads,proto3" json:"workloads,omitempty"` StartTime *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=start_time,json=startTime,proto3,oneof" json:"start_time,omitempty"` EndTime *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=end_time,json=endTime,proto3,oneof" json:"end_time,omitempty"` - // When set to 1D or 7D, serve from the persisted workload_profile_cache - // snapshot for that window instead of computing live over start_time/end_time. + // When set to 1D or 7D, serve the persisted current profile state for that + // window instead of computing live over start_time/end_time. // UNSPECIFIED (default) preserves today's live-compute behavior. Window ProfileWindow `protobuf:"varint,13,opt,name=window,proto3,enum=api.v1.ProfileWindow" json:"window,omitempty"` } diff --git a/internal/proto/api/v1/profiling.proto b/internal/proto/api/v1/profiling.proto index 86c530b..3be3d38 100644 --- a/internal/proto/api/v1/profiling.proto +++ b/internal/proto/api/v1/profiling.proto @@ -35,8 +35,8 @@ message GetWorkloadProfilesRequest { optional google.protobuf.Timestamp start_time = 11; optional google.protobuf.Timestamp end_time = 12; - // When set to 1D or 7D, serve from the persisted workload_profile_cache - // snapshot for that window instead of computing live over start_time/end_time. + // When set to 1D or 7D, serve the persisted current profile state for that + // window instead of computing live over start_time/end_time. // UNSPECIFIED (default) preserves today's live-compute behavior. ProfileWindow window = 13; } From 9a0b1915cc2287083c1f7788c2b61e225726deca Mon Sep 17 00:00:00 2001 From: Rupam-It Date: Wed, 26 Aug 2026 19:48:50 +0530 Subject: [PATCH 2/6] Add the gcp and oci blocks (image/subnet/security-group selectors, kubelet config, disks, boot config, launch options), the instanceShapes selector, and the instanceShapesTip/startupTaintsTip/instanceLocalNvmeTip tooltip fields, bringing node_policy to parity with the Terraform provider. Signed-off-by: Rupam-It --- provider/pkg/resources/node_policy.go | 396 +++++++++++++++++++++++++- 1 file changed, 395 insertions(+), 1 deletion(-) diff --git a/provider/pkg/resources/node_policy.go b/provider/pkg/resources/node_policy.go index 7ef15c0..c3e962b 100644 --- a/provider/pkg/resources/node_policy.go +++ b/provider/pkg/resources/node_policy.go @@ -313,6 +313,176 @@ func (a *AzureNodeClassSpecArgs) Annotate(ann infer.Annotator) { ann.Describe(&a.MaxPods, "Maximum pods per node, overrides the AKS cluster default. Example: 110.") } +// GCPImageSelectorTermArgs selects a GCP node image. +type GCPImageSelectorTermArgs struct { + Alias string `pulumi:"alias,optional"` + Id string `pulumi:"id,optional"` +} + +// Annotate provides SDK documentation for GCPImageSelectorTermArgs fields. +func (g *GCPImageSelectorTermArgs) Annotate(a infer.Annotator) { + a.Describe(&g.Alias, "Well-known alias for the GCP node image family. Example: 'cos@latest'.") + a.Describe(&g.Id, "Explicit GCP image ID. Example: 'projects/cos-cloud/global/images/cos-105-17412-156-59'.") +} + +// GCPDiskArgs configures a disk attached to a GCP node. +type GCPDiskArgs struct { + SizeGib int `pulumi:"sizeGib,optional"` + Category string `pulumi:"category,optional"` + Boot bool `pulumi:"boot,optional"` + SecondaryBootImage string `pulumi:"secondaryBootImage,optional"` + SecondaryBootMode string `pulumi:"secondaryBootMode,optional"` +} + +// Annotate provides SDK documentation for GCPDiskArgs fields. +func (g *GCPDiskArgs) Annotate(a infer.Annotator) { + a.Describe(&g.SizeGib, "Disk size in GiB. Example: 100.") + a.Describe(&g.Category, "GCP disk type. Example: 'pd-ssd'.") + a.Describe(&g.Boot, "Whether this disk is the boot disk. Example: true.") + a.Describe(&g.SecondaryBootImage, "Secondary boot image used for container-image fast boot. Example: 'projects/my-project/global/images/my-cache-image'.") + a.Describe(&g.SecondaryBootMode, "Secondary boot mode. Example: 'CONTAINER_IMAGE_CACHE'.") +} + +// GCPNodeClassSpecArgs holds GCP-specific node class configuration. +type GCPNodeClassSpecArgs struct { + ServiceAccount string `pulumi:"serviceAccount,optional"` + ImageSelectorTerms []GCPImageSelectorTermArgs `pulumi:"imageSelectorTerms,optional"` + ImageFamily *string `pulumi:"imageFamily,optional"` + Kubelet *KubeletConfigurationArgs `pulumi:"kubelet,optional"` + Labels map[string]string `pulumi:"labels,optional"` + Metadata map[string]string `pulumi:"metadata,optional"` + NetworkTags []string `pulumi:"networkTags,optional"` + Disks []GCPDiskArgs `pulumi:"disks,optional"` +} + +// Annotate provides SDK documentation for GCPNodeClassSpecArgs fields. +func (g *GCPNodeClassSpecArgs) Annotate(a infer.Annotator) { + a.Describe(&g.ServiceAccount, "GCP service account email attached to provisioned nodes. Example: 'karpenter@my-project.iam.gserviceaccount.com'.") + a.Describe(&g.ImageSelectorTerms, "Selectors for the node images used to launch nodes. Example: [{alias: \"cos@latest\"}].") + a.Describe(&g.ImageFamily, "GCP node image family shorthand used when no imageSelectorTerms are specified. Example: 'cos'.") + a.Describe(&g.Kubelet, "Kubelet configuration overrides applied to all nodes in this class.") + a.Describe(&g.Labels, "GCP labels applied to all resources created by this node class. Example: {\"environment\": \"production\"}.") + a.Describe(&g.Metadata, "GCE instance metadata applied to provisioned nodes. Example: {\"disable-legacy-endpoints\": \"true\"}.") + a.Describe(&g.NetworkTags, "GCP network tags applied to provisioned nodes for firewall targeting. Example: [\"karpenter-node\"].") + a.Describe(&g.Disks, "Disks attached to provisioned nodes. Example: [{sizeGib: 100, category: \"pd-ssd\", boot: true}].") +} + +// OCIImageSelectorTermArgs selects an OCI node image. +type OCIImageSelectorTermArgs struct { + Id string `pulumi:"id,optional"` + Name string `pulumi:"name,optional"` + CompartmentId string `pulumi:"compartmentId,optional"` +} + +// Annotate provides SDK documentation for OCIImageSelectorTermArgs fields. +func (o *OCIImageSelectorTermArgs) Annotate(a infer.Annotator) { + a.Describe(&o.Id, "Explicit OCI image OCID. Example: 'ocid1.image.oc1..aaaaaaaa'.") + a.Describe(&o.Name, "OCI image display name filter. Example: 'Oracle-Linux-8.9'.") + a.Describe(&o.CompartmentId, "OCID of the compartment containing the image. Example: 'ocid1.compartment.oc1..aaaaaaaa'.") +} + +// OCISubnetSelectorTermArgs selects an OCI subnet. +type OCISubnetSelectorTermArgs struct { + Id string `pulumi:"id,optional"` + Name string `pulumi:"name,optional"` +} + +// Annotate provides SDK documentation for OCISubnetSelectorTermArgs fields. +func (o *OCISubnetSelectorTermArgs) Annotate(a infer.Annotator) { + a.Describe(&o.Id, "Explicit OCI subnet OCID. Example: 'ocid1.subnet.oc1..aaaaaaaa'.") + a.Describe(&o.Name, "OCI subnet display name filter. Example: 'node-subnet'.") +} + +// OCISecurityGroupSelectorTermArgs selects an OCI network security group. +type OCISecurityGroupSelectorTermArgs struct { + Id string `pulumi:"id,optional"` + Name string `pulumi:"name,optional"` +} + +// Annotate provides SDK documentation for OCISecurityGroupSelectorTermArgs fields. +func (o *OCISecurityGroupSelectorTermArgs) Annotate(a infer.Annotator) { + a.Describe(&o.Id, "Explicit OCI network security group OCID. Example: 'ocid1.networksecuritygroup.oc1..aaaaaaaa'.") + a.Describe(&o.Name, "OCI network security group display name filter. Example: 'node-nsg'.") +} + +// OCIBootConfigArgs configures the OCI boot volume. +type OCIBootConfigArgs struct { + BootVolumeSizeInGbs int `pulumi:"bootVolumeSizeInGbs,optional"` + BootVolumeVpusPerGb int `pulumi:"bootVolumeVpusPerGb,optional"` +} + +// Annotate provides SDK documentation for OCIBootConfigArgs fields. +func (o *OCIBootConfigArgs) Annotate(a infer.Annotator) { + a.Describe(&o.BootVolumeSizeInGbs, "Boot volume size in GB. Example: 100.") + a.Describe(&o.BootVolumeVpusPerGb, "Boot volume performance units per GB. Example: 10.") +} + +// OCILaunchOptionsArgs configures OCI instance launch options. +type OCILaunchOptionsArgs struct { + BootVolumeType *string `pulumi:"bootVolumeType,optional"` + Firmware *string `pulumi:"firmware,optional"` + NetworkType *string `pulumi:"networkType,optional"` + RemoteDataVolumeType *string `pulumi:"remoteDataVolumeType,optional"` + IsConsistentVolumeNamingEnabled *bool `pulumi:"isConsistentVolumeNamingEnabled,optional"` +} + +// Annotate provides SDK documentation for OCILaunchOptionsArgs fields. +func (o *OCILaunchOptionsArgs) Annotate(a infer.Annotator) { + a.Describe(&o.BootVolumeType, "Emulation type for the boot volume. Example: 'PARAVIRTUALIZED'.") + a.Describe(&o.Firmware, "Firmware used to boot the instance. Example: 'UEFI_64'.") + a.Describe(&o.NetworkType, "Emulation type for the network interface. Example: 'PARAVIRTUALIZED'.") + a.Describe(&o.RemoteDataVolumeType, "Emulation type for remote data volumes. Example: 'PARAVIRTUALIZED'.") + a.Describe(&o.IsConsistentVolumeNamingEnabled, "Whether consistent volume naming is enabled for the instance. Example: true.") +} + +// OCIVolumeAttributesArgs configures an OCI block volume. +type OCIVolumeAttributesArgs struct { + SizeInGbs int `pulumi:"sizeInGbs,optional"` + VpusPerGb int `pulumi:"vpusPerGb,optional"` +} + +// Annotate provides SDK documentation for OCIVolumeAttributesArgs fields. +func (o *OCIVolumeAttributesArgs) Annotate(a infer.Annotator) { + a.Describe(&o.SizeInGbs, "Block volume size in GB. Example: 50.") + a.Describe(&o.VpusPerGb, "Block volume performance units per GB. Example: 10.") +} + +// OCINodeClassSpecArgs holds OCI-specific node class configuration. +type OCINodeClassSpecArgs struct { + VcnId string `pulumi:"vcnId,optional"` + ImageSelector []OCIImageSelectorTermArgs `pulumi:"imageSelector,optional"` + SubnetSelector []OCISubnetSelectorTermArgs `pulumi:"subnetSelector,optional"` + SecurityGroupSelector []OCISecurityGroupSelectorTermArgs `pulumi:"securityGroupSelector,optional"` + UserData *string `pulumi:"userData,optional"` + PreInstallScript *string `pulumi:"preInstallScript,optional"` + MetaData map[string]string `pulumi:"metaData,optional"` + ImageFamily string `pulumi:"imageFamily,optional"` + Tags map[string]string `pulumi:"tags,optional"` + FreeFormTags map[string]string `pulumi:"freeFormTags,optional"` + BootConfig *OCIBootConfigArgs `pulumi:"bootConfig,optional"` + LaunchOptions *OCILaunchOptionsArgs `pulumi:"launchOptions,optional"` + BlockDevices []OCIVolumeAttributesArgs `pulumi:"blockDevices,optional"` + AgentList []string `pulumi:"agentList,optional"` +} + +// Annotate provides SDK documentation for OCINodeClassSpecArgs fields. +func (o *OCINodeClassSpecArgs) Annotate(a infer.Annotator) { + a.Describe(&o.VcnId, "OCID of the VCN nodes will be launched into. Example: 'ocid1.vcn.oc1..aaaaaaaa'.") + a.Describe(&o.ImageSelector, "Selectors for the images used to launch nodes. Example: [{name: \"Oracle-Linux-8.9\"}].") + a.Describe(&o.SubnetSelector, "Selectors for the subnets nodes will be launched into.") + a.Describe(&o.SecurityGroupSelector, "Selectors for network security groups attached to provisioned nodes.") + a.Describe(&o.UserData, "Custom cloud-init user data merged into the node launch config (base64 or plain text). Example: '#!/bin/bash\\necho hello'.") + a.Describe(&o.PreInstallScript, "Script executed before node bootstrap. Example: '#!/bin/bash\\necho pre-install'.") + a.Describe(&o.MetaData, "OCI instance metadata applied to provisioned nodes. Example: {\"ssh_authorized_keys\": \"ssh-rsa ...\"}.") + a.Describe(&o.ImageFamily, "OCI node image family shorthand used when no imageSelector is specified. Example: 'Oracle-Linux-8'.") + a.Describe(&o.Tags, "OCI defined tags applied to all resources created by this node class.") + a.Describe(&o.FreeFormTags, "OCI free-form tags applied to all resources created by this node class. Example: {\"environment\": \"production\"}.") + a.Describe(&o.BootConfig, "Boot volume configuration for provisioned nodes.") + a.Describe(&o.LaunchOptions, "Instance launch options controlling firmware and network/volume emulation type.") + a.Describe(&o.BlockDevices, "Additional block volumes attached to provisioned nodes.") + a.Describe(&o.AgentList, "OCI compute instance agent plugins to enable. Example: [\"Compute Instance Monitoring\"].") +} + // RawKarpenterSpecArgs provides raw YAML for a custom Karpenter node pool / node class. type RawKarpenterSpecArgs struct { NodepoolYaml string `pulumi:"nodepoolYaml,optional"` @@ -338,7 +508,11 @@ type NodePolicyArgs struct { InstanceHypervisors *LabelSelectorArgs `pulumi:"instanceHypervisors,optional"` InstanceGenerations *LabelSelectorArgs `pulumi:"instanceGenerations,optional"` InstanceSizes *LabelSelectorArgs `pulumi:"instanceSizes,optional"` - InstanceTypes *LabelSelectorArgs `pulumi:"instanceTypes,optional"` + // GCP-only: standard/highcpu/highmem shape token. + InstanceShapes *LabelSelectorArgs `pulumi:"instanceShapes,optional"` + // UI tooltip text for the instanceShapes selector. + InstanceShapesTip *string `pulumi:"instanceShapesTip,optional"` + InstanceTypes *LabelSelectorArgs `pulumi:"instanceTypes,optional"` // Node attribute selectors Zones *LabelSelectorArgs `pulumi:"zones,optional"` @@ -350,6 +524,8 @@ type NodePolicyArgs struct { Labels map[string]string `pulumi:"labels,optional"` Taints []TaintArgs `pulumi:"taints,optional"` StartupTaints []TaintArgs `pulumi:"startupTaints,optional"` + // UI tooltip text for startupTaints. + StartupTaintsTip *string `pulumi:"startupTaintsTip,optional"` // Policy configuration Disruption *DisruptionPolicyArgs `pulumi:"disruption,optional"` @@ -362,11 +538,15 @@ type NodePolicyArgs struct { // Cloud-specific configuration Aws *AWSNodeClassSpecArgs `pulumi:"aws,optional"` Azure *AzureNodeClassSpecArgs `pulumi:"azure,optional"` + Gcp *GCPNodeClassSpecArgs `pulumi:"gcp,optional"` + Oci *OCINodeClassSpecArgs `pulumi:"oci,optional"` // AWS-only: behavior during an ARC zonal shift. ZonalShift *ZonalShiftConfigArgs `pulumi:"zonalShift,optional"` // AWS-only: ephemeral NVMe storage per node in GiB (karpenter.k8s.aws/instance-local-nvme). InstanceLocalNvme *LabelSelectorArgs `pulumi:"instanceLocalNvme,optional"` + // UI tooltip text for the instanceLocalNvme selector. + InstanceLocalNvmeTip *string `pulumi:"instanceLocalNvmeTip,optional"` // Informational: 1 = AWS, 2 = Azure, 3 = GCP, 4 = OCI. Compilation always uses the target cluster's provider. CloudProviderId *int `pulumi:"cloudProviderId,optional"` // AWS fallback for aws.role when neither role nor instanceProfile is set. @@ -392,6 +572,8 @@ func (s *NodePolicyState) Annotate(a infer.Annotator) { a.Describe(&s.InstanceHypervisors, "Filter instances by hypervisor type. Example: {in: [\"nitro\"]}.") a.Describe(&s.InstanceGenerations, "Filter instances by generation number. Example: {in: [\"2\", \"3\"]}.") a.Describe(&s.InstanceSizes, "Filter instances by size label. Example: {in: [\"large\", \"xlarge\", \"2xlarge\"]}.") + a.Describe(&s.InstanceShapes, "GCP-only: filter by standard/highcpu/highmem custom shape token. Example: {in: [\"standard\", \"highmem\"]}.") + a.Describe(&s.InstanceShapesTip, "UI tooltip text shown alongside the instanceShapes selector.") a.Describe(&s.InstanceTypes, "Explicitly allow specific instance types. Example: {in: [\"m5.large\", \"c6i.large\"]}.") a.Describe(&s.Zones, "Availability zones where nodes may be provisioned. Example: {in: [\"us-east-1a\", \"us-east-1b\"]}.") a.Describe(&s.Architectures, "CPU architectures for nodes. Example: {in: [\"amd64\"]}.") @@ -399,12 +581,16 @@ func (s *NodePolicyState) Annotate(a infer.Annotator) { a.Describe(&s.OperatingSystems, "Operating systems for nodes. Example: {in: [\"linux\"]}.") a.Describe(&s.Labels, "Labels applied to all provisioned nodes. Example: {\"team\": \"backend\", \"env\": \"prod\"}.") a.Describe(&s.Taints, "Taints applied to provisioned nodes to control pod scheduling. Example: [{key: \"dedicated\", value: \"gpu\", effect: \"NoSchedule\"}].") + a.Describe(&s.StartupTaintsTip, "UI tooltip text shown alongside startupTaints.") a.Describe(&s.Disruption, "Karpenter disruption policy controlling consolidation, expiry, and budgets.") a.Describe(&s.Limits, "Resource limits on total capacity managed by this policy. Example: {cpu: \"1000\", memory: \"1000Gi\"}.") a.Describe(&s.NodePoolName, "Override name for the generated Karpenter NodePool resource. Example: 'prod-spot-nodepool'.") a.Describe(&s.NodeClassName, "Override name for the generated Karpenter NodeClass resource. Example: 'prod-aws-nodeclass'.") a.Describe(&s.Aws, "AWS-specific EC2NodeClass configuration (subnets, AMIs, IAM role, EBS, etc.).") a.Describe(&s.Azure, "Azure-specific AKSNodeClass configuration (VNet subnet, OS disk, image family, etc.).") + a.Describe(&s.Gcp, "GCP-specific GCENodeClass configuration (service account, images, disks, etc.).") + a.Describe(&s.Oci, "OCI-specific NodeClass configuration (VCN, subnets, images, block volumes, etc.).") + a.Describe(&s.InstanceLocalNvmeTip, "UI tooltip text shown alongside the instanceLocalNvme selector.") a.Describe(&s.Raw, "Raw Karpenter YAML for full NodePool/NodeClass customization — use only when structured fields are insufficient.") } @@ -551,8 +737,11 @@ func nodePolicyArgsToProto(teamID, id string, a NodePolicyArgs) *apiv1.NodePolic Limits: resourceLimitsToProto(a.Limits), Aws: awsNodeClassSpecToProto(a.Aws), Azure: azureNodeClassSpecToProto(a.Azure), + Gcp: gcpNodeClassSpecToProto(a.Gcp), + Oci: ociNodeClassSpecToProto(a.Oci), Raw: rawKarpenterSpecsToProto(a.Raw), InstanceLocalNvme: labelSelectorToProto(a.InstanceLocalNvme), + InstanceShapes: labelSelectorToProto(a.InstanceShapes), } if a.Description != nil { p.Description = *a.Description @@ -571,6 +760,15 @@ func nodePolicyArgsToProto(teamID, id string, a NodePolicyArgs) *apiv1.NodePolic if a.MasterOverrideRoleName != nil { p.MasterOverrideRoleName = *a.MasterOverrideRoleName } + if a.InstanceShapesTip != nil { + p.InstanceShapesTip = a.InstanceShapesTip + } + if a.StartupTaintsTip != nil { + p.StartupTaintsTip = a.StartupTaintsTip + } + if a.InstanceLocalNvmeTip != nil { + p.InstanceLocalNvmeTip = a.InstanceLocalNvmeTip + } return p } @@ -598,8 +796,11 @@ func nodePolicyProtoToArgs(p *apiv1.NodePolicy) NodePolicyArgs { Limits: resourceLimitsFromProto(p.Limits), Aws: awsNodeClassSpecFromProto(p.Aws), Azure: azureNodeClassSpecFromProto(p.Azure), + Gcp: gcpNodeClassSpecFromProto(p.Gcp), + Oci: ociNodeClassSpecFromProto(p.Oci), Raw: rawKarpenterSpecsFromProto(p.Raw), InstanceLocalNvme: labelSelectorFromProto(p.InstanceLocalNvme), + InstanceShapes: labelSelectorFromProto(p.InstanceShapes), } if p.Description != "" { a.Description = &p.Description @@ -615,6 +816,9 @@ func nodePolicyProtoToArgs(p *apiv1.NodePolicy) NodePolicyArgs { if p.MasterOverrideRoleName != "" { a.MasterOverrideRoleName = &p.MasterOverrideRoleName } + a.InstanceShapesTip = p.InstanceShapesTip + a.StartupTaintsTip = p.StartupTaintsTip + a.InstanceLocalNvmeTip = p.InstanceLocalNvmeTip return a } @@ -1222,3 +1426,193 @@ func azureKubeletConfigFromProto(cfg *apiv1.AzureKubeletConfiguration) *AzureKub } return k } + +// ---------- GCP NodeClass helpers ---------- + +func gcpNodeClassSpecToProto(g *GCPNodeClassSpecArgs) *apiv1.GCPNodeClassSpec { + if g == nil { + return nil + } + spec := &apiv1.GCPNodeClassSpec{ + ServiceAccount: g.ServiceAccount, + KubeletConfiguration: kubeletConfigToProto(g.Kubelet), + Labels: g.Labels, + Metadata: g.Metadata, + NetworkTags: g.NetworkTags, + } + if g.ImageFamily != nil { + spec.ImageFamily = g.ImageFamily + } + for _, t := range g.ImageSelectorTerms { + spec.ImageSelectorTerms = append(spec.ImageSelectorTerms, &apiv1.GCPImageSelectorTerm{ + Alias: t.Alias, + Id: t.Id, + }) + } + for _, d := range g.Disks { + spec.Disks = append(spec.Disks, &apiv1.GCPDisk{ + SizeGib: int32(d.SizeGib), + Category: d.Category, + Boot: d.Boot, + SecondaryBootImage: d.SecondaryBootImage, + SecondaryBootMode: d.SecondaryBootMode, + }) + } + return spec +} + +func gcpNodeClassSpecFromProto(spec *apiv1.GCPNodeClassSpec) *GCPNodeClassSpecArgs { + if spec == nil { + return nil + } + g := &GCPNodeClassSpecArgs{ + ServiceAccount: spec.ServiceAccount, + Kubelet: kubeletConfigFromProto(spec.KubeletConfiguration), + Labels: spec.Labels, + Metadata: spec.Metadata, + NetworkTags: spec.NetworkTags, + } + if spec.ImageFamily != nil { + g.ImageFamily = spec.ImageFamily + } + for _, t := range spec.ImageSelectorTerms { + g.ImageSelectorTerms = append(g.ImageSelectorTerms, GCPImageSelectorTermArgs{ + Alias: t.Alias, + Id: t.Id, + }) + } + for _, d := range spec.Disks { + g.Disks = append(g.Disks, GCPDiskArgs{ + SizeGib: int(d.SizeGib), + Category: d.Category, + Boot: d.Boot, + SecondaryBootImage: d.SecondaryBootImage, + SecondaryBootMode: d.SecondaryBootMode, + }) + } + return g +} + +// ---------- OCI NodeClass helpers ---------- + +func ociNodeClassSpecToProto(o *OCINodeClassSpecArgs) *apiv1.OCINodeClassSpec { + if o == nil { + return nil + } + spec := &apiv1.OCINodeClassSpec{ + VcnId: o.VcnId, + MetaData: o.MetaData, + ImageFamily: o.ImageFamily, + Tags: o.Tags, + FreeFormTags: o.FreeFormTags, + AgentList: o.AgentList, + } + if o.UserData != nil { + spec.UserData = o.UserData + } + if o.PreInstallScript != nil { + spec.PreInstallScript = o.PreInstallScript + } + for _, t := range o.ImageSelector { + spec.ImageSelector = append(spec.ImageSelector, &apiv1.OCIImageSelectorTerm{ + Id: t.Id, + Name: t.Name, + CompartmentId: t.CompartmentId, + }) + } + for _, t := range o.SubnetSelector { + spec.SubnetSelector = append(spec.SubnetSelector, &apiv1.OCISubnetSelectorTerm{ + Id: t.Id, + Name: t.Name, + }) + } + for _, t := range o.SecurityGroupSelector { + spec.SecurityGroupSelector = append(spec.SecurityGroupSelector, &apiv1.OCISecurityGroupSelectorTerm{ + Id: t.Id, + Name: t.Name, + }) + } + if o.BootConfig != nil { + spec.BootConfig = &apiv1.OCIBootConfig{ + BootVolumeSizeInGbs: int64(o.BootConfig.BootVolumeSizeInGbs), + BootVolumeVpusPerGb: int64(o.BootConfig.BootVolumeVpusPerGb), + } + } + if o.LaunchOptions != nil { + spec.LaunchOptions = &apiv1.OCILaunchOptions{ + BootVolumeType: o.LaunchOptions.BootVolumeType, + Firmware: o.LaunchOptions.Firmware, + NetworkType: o.LaunchOptions.NetworkType, + RemoteDataVolumeType: o.LaunchOptions.RemoteDataVolumeType, + IsConsistentVolumeNamingEnabled: o.LaunchOptions.IsConsistentVolumeNamingEnabled, + } + } + for _, b := range o.BlockDevices { + spec.BlockDevices = append(spec.BlockDevices, &apiv1.OCIVolumeAttributes{ + SizeInGbs: int64(b.SizeInGbs), + VpusPerGb: int64(b.VpusPerGb), + }) + } + return spec +} + +func ociNodeClassSpecFromProto(spec *apiv1.OCINodeClassSpec) *OCINodeClassSpecArgs { + if spec == nil { + return nil + } + o := &OCINodeClassSpecArgs{ + VcnId: spec.VcnId, + MetaData: spec.MetaData, + ImageFamily: spec.ImageFamily, + Tags: spec.Tags, + FreeFormTags: spec.FreeFormTags, + AgentList: spec.AgentList, + } + if spec.UserData != nil { + o.UserData = spec.UserData + } + if spec.PreInstallScript != nil { + o.PreInstallScript = spec.PreInstallScript + } + for _, t := range spec.ImageSelector { + o.ImageSelector = append(o.ImageSelector, OCIImageSelectorTermArgs{ + Id: t.Id, + Name: t.Name, + CompartmentId: t.CompartmentId, + }) + } + for _, t := range spec.SubnetSelector { + o.SubnetSelector = append(o.SubnetSelector, OCISubnetSelectorTermArgs{ + Id: t.Id, + Name: t.Name, + }) + } + for _, t := range spec.SecurityGroupSelector { + o.SecurityGroupSelector = append(o.SecurityGroupSelector, OCISecurityGroupSelectorTermArgs{ + Id: t.Id, + Name: t.Name, + }) + } + if spec.BootConfig != nil { + o.BootConfig = &OCIBootConfigArgs{ + BootVolumeSizeInGbs: int(spec.BootConfig.BootVolumeSizeInGbs), + BootVolumeVpusPerGb: int(spec.BootConfig.BootVolumeVpusPerGb), + } + } + if spec.LaunchOptions != nil { + o.LaunchOptions = &OCILaunchOptionsArgs{ + BootVolumeType: spec.LaunchOptions.BootVolumeType, + Firmware: spec.LaunchOptions.Firmware, + NetworkType: spec.LaunchOptions.NetworkType, + RemoteDataVolumeType: spec.LaunchOptions.RemoteDataVolumeType, + IsConsistentVolumeNamingEnabled: spec.LaunchOptions.IsConsistentVolumeNamingEnabled, + } + } + for _, b := range spec.BlockDevices { + o.BlockDevices = append(o.BlockDevices, OCIVolumeAttributesArgs{ + SizeInGbs: int(b.SizeInGbs), + VpusPerGb: int(b.VpusPerGb), + }) + } + return o +} From e0e9ed0d19d4093092a17f12e8b625cfd1656a13 Mon Sep 17 00:00:00 2001 From: Rupam-It Date: Wed, 26 Aug 2026 20:09:18 +0530 Subject: [PATCH 3/6] feat(workload_rule): add JVM heap rule, KEDA scaled object, and allowInPlaceMemoryLimitDecrease Signed-off-by: Rupam-It --- provider/pkg/resources/roundtrip_test.go | 48 +-- provider/pkg/resources/workload_rule.go | 469 ++++++++++++++++++++--- 2 files changed, 447 insertions(+), 70 deletions(-) diff --git a/provider/pkg/resources/roundtrip_test.go b/provider/pkg/resources/roundtrip_test.go index 6b7bd7b..7d28ff5 100644 --- a/provider/pkg/resources/roundtrip_test.go +++ b/provider/pkg/resources/roundtrip_test.go @@ -213,28 +213,32 @@ func TestRoundTrip_AllFields_WorkloadRule(t *testing.T) { // Synthesize the rule the server would echo back for these fields. f := req1.Fields echo := &apiv1.WorkloadRule{ - RuleId: "id", - ClusterId: req1.ClusterId, - Namespace: req1.Namespace, - Kind: req1.Kind, - Name: req1.Name, - CurrentSource: "pulumi_manual", - CpuRule: f.CpuRule, - MemoryRule: f.MemoryRule, - GpuRule: f.GpuRule, - HpaRule: f.HpaRule, - EmergencyResponse: f.EmergencyResponse, - ActionTriggers: f.ActionTriggers, - DetectionTriggers: f.DetectionTriggers, - SchedulerPlugins: f.SchedulerPlugins, - LiveMigrationEnabled: f.LiveMigrationEnabled, - UseInPlaceVerticalScaling: f.UseInPlaceVerticalScaling, - Containers: f.Containers, - StartupPeriodSeconds: f.StartupPeriodSeconds, - CronSchedule: f.CronSchedule, - CooldownMinutes: f.CooldownMinutes, - DefragmentationSchedule: f.DefragmentationSchedule, - LookbackPeriodSeconds: f.LookbackPeriodSeconds, + RuleId: "id", + ClusterId: req1.ClusterId, + Namespace: req1.Namespace, + Kind: req1.Kind, + Name: req1.Name, + CurrentSource: "pulumi_manual", + CpuRule: f.CpuRule, + MemoryRule: f.MemoryRule, + GpuRule: f.GpuRule, + HpaRule: f.HpaRule, + EmergencyResponse: f.EmergencyResponse, + ActionTriggers: f.ActionTriggers, + DetectionTriggers: f.DetectionTriggers, + SchedulerPlugins: f.SchedulerPlugins, + LiveMigrationEnabled: f.LiveMigrationEnabled, + UseInPlaceVerticalScaling: f.UseInPlaceVerticalScaling, + Containers: f.Containers, + StartupPeriodSeconds: f.StartupPeriodSeconds, + CronSchedule: f.CronSchedule, + CooldownMinutes: f.CooldownMinutes, + DefragmentationSchedule: f.DefragmentationSchedule, + LookbackPeriodSeconds: f.LookbackPeriodSeconds, + AllowInPlaceMemoryLimitDecrease: f.AllowInPlaceMemoryLimitDecrease, + JvmHeapRule: f.JvmHeapRule, + JvmCpuStartupFloorMillicores: f.JvmCpuStartupFloorMillicores, + KedaScaledObject: f.KedaScaledObject, } if f.Disabled != nil { echo.Disabled = *f.Disabled diff --git a/provider/pkg/resources/workload_rule.go b/provider/pkg/resources/workload_rule.go index e2bdd97..5354bbc 100644 --- a/provider/pkg/resources/workload_rule.go +++ b/provider/pkg/resources/workload_rule.go @@ -176,6 +176,114 @@ func (e *EmergencyResponseConfigArgs) Annotate(a infer.Annotator) { a.Describe(&e.CpuThrottlingMultiplier, "Multiplier applied to CPU request on throttle reaction. Example: 1.5.") } +// JvmHeapRuleConfigArgs configures JVM heap sizing overrides on a WorkloadRule. +type JvmHeapRuleConfigArgs struct { + Enabled bool `pulumi:"enabled,optional"` + TargetPercentile *float64 `pulumi:"targetPercentile,optional"` + HeadroomMultiplier *float64 `pulumi:"headroomMultiplier,optional"` + NonHeapOverheadPercent *float64 `pulumi:"nonHeapOverheadPercent,optional"` + NonHeapOverheadBytes *int `pulumi:"nonHeapOverheadBytes,optional"` + MinHeapBytes *int `pulumi:"minHeapBytes,optional"` + MaxHeapBytes *int `pulumi:"maxHeapBytes,optional"` + PreferContainerSupport bool `pulumi:"preferContainerSupport,optional"` +} + +// Annotate provides SDK documentation for JvmHeapRuleConfigArgs fields. +func (j *JvmHeapRuleConfigArgs) Annotate(a infer.Annotator) { + a.Describe(&j.Enabled, "Enable JVM heap sizing overrides. Example: true.") + a.Describe(&j.TargetPercentile, "Percentile of usage data used as the heap sizing target (0-1). Example: 0.95.") + a.Describe(&j.HeadroomMultiplier, "Multiplier applied above the target usage to derive the heap size. Example: 1.3.") + a.Describe(&j.NonHeapOverheadPercent, "Non-heap memory overhead as a percentage of container memory (0-1). Example: 0.2.") + a.Describe(&j.NonHeapOverheadBytes, "Non-heap memory overhead in bytes. Takes precedence over nonHeapOverheadPercent when set. Example: 268435456.") + a.Describe(&j.MinHeapBytes, "Minimum JVM heap size in bytes. Example: 134217728.") + a.Describe(&j.MaxHeapBytes, "Maximum JVM heap size in bytes. Example: 2147483648.") + a.Describe(&j.PreferContainerSupport, "Prefer the JVM's native container-aware heap sizing (-XX:+UseContainerSupport) over explicit -Xmx/-Xms flags. Example: false.") +} + +// KedaAuthenticationRefArgs references a KEDA TriggerAuthentication or ClusterTriggerAuthentication. +type KedaAuthenticationRefArgs struct { + Name string `pulumi:"name"` + Kind string `pulumi:"kind,optional"` +} + +// Annotate provides SDK documentation for KedaAuthenticationRefArgs fields. +func (k *KedaAuthenticationRefArgs) Annotate(a infer.Annotator) { + a.Describe(&k.Name, "Name of the referenced TriggerAuthentication/ClusterTriggerAuthentication resource. Example: 'prometheus-auth'.") + a.Describe(&k.Kind, "Kind of the referenced resource. One of: 'TriggerAuthentication', 'ClusterTriggerAuthentication'. Example: 'TriggerAuthentication'.") +} + +// KedaTriggerArgs configures a single KEDA ScaledObject trigger. +type KedaTriggerArgs struct { + Type string `pulumi:"type"` + Name string `pulumi:"name,optional"` + Metadata map[string]string `pulumi:"metadata,optional"` + MetricType string `pulumi:"metricType,optional"` + AuthenticationRef *KedaAuthenticationRefArgs `pulumi:"authenticationRef,optional"` + UseCachedMetrics bool `pulumi:"useCachedMetrics,optional"` +} + +// Annotate provides SDK documentation for KedaTriggerArgs fields. +func (k *KedaTriggerArgs) Annotate(a infer.Annotator) { + a.Describe(&k.Type, "KEDA scaler type. Example: 'prometheus'.") + a.Describe(&k.Name, "Optional trigger name, used to disambiguate multiple triggers of the same type. Example: 'requests-per-second'.") + a.Describe(&k.Metadata, "Scaler-specific configuration key-value pairs. Example: {\"serverAddress\": \"http://prometheus:9090\", \"query\": \"sum(rate(http_requests_total[2m]))\"}.") + a.Describe(&k.MetricType, "Metric target type. One of: 'Value', 'AverageValue', 'Utilization'. Example: 'AverageValue'.") + a.Describe(&k.AuthenticationRef, "Reference to a TriggerAuthentication or ClusterTriggerAuthentication for this trigger.") + a.Describe(&k.UseCachedMetrics, "Use KEDA's metric caching for this trigger. Example: false.") +} + +// KedaFallbackArgs configures replica fallback when KEDA metrics are unavailable. +type KedaFallbackArgs struct { + FailureThreshold int `pulumi:"failureThreshold"` + Replicas int `pulumi:"replicas"` + Behavior string `pulumi:"behavior,optional"` +} + +// Annotate provides SDK documentation for KedaFallbackArgs fields. +func (k *KedaFallbackArgs) Annotate(a infer.Annotator) { + a.Describe(&k.FailureThreshold, "Number of consecutive metric failures before activating fallback. Example: 3.") + a.Describe(&k.Replicas, "Number of replicas to fall back to when metrics are unavailable. Example: 2.") + a.Describe(&k.Behavior, "Fallback strategy. Example: 'static'.") +} + +// KedaAdvancedArgs configures advanced KEDA ScaledObject behavior. +type KedaAdvancedArgs struct { + RestoreToOriginalReplicaCount bool `pulumi:"restoreToOriginalReplicaCount,optional"` + AdvancedBehaviorJson string `pulumi:"advancedBehaviorJson,optional"` +} + +// Annotate provides SDK documentation for KedaAdvancedArgs fields. +func (k *KedaAdvancedArgs) Annotate(a infer.Annotator) { + a.Describe(&k.RestoreToOriginalReplicaCount, "Restore the original replica count when the ScaledObject is deleted. Example: false.") + a.Describe(&k.AdvancedBehaviorJson, "Kubernetes HorizontalPodAutoscalerBehavior encoded as a JSON string, applied to the generated HPA. Example: '{\"scaleDown\":{\"stabilizationWindowSeconds\":300}}'.") +} + +// KedaScaledObjectArgs configures a KEDA ScaledObject managed alongside the workload. +type KedaScaledObjectArgs struct { + Triggers []KedaTriggerArgs `pulumi:"triggers,optional"` + MinReplicaCount *int `pulumi:"minReplicaCount,optional"` + MaxReplicaCount *int `pulumi:"maxReplicaCount,optional"` + IdleReplicaCount *int `pulumi:"idleReplicaCount,optional"` + PollingInterval *int `pulumi:"pollingInterval,optional"` + CooldownPeriod *int `pulumi:"cooldownPeriod,optional"` + InitialCooldownPeriod *int `pulumi:"initialCooldownPeriod,optional"` + Fallback *KedaFallbackArgs `pulumi:"fallback,optional"` + Advanced *KedaAdvancedArgs `pulumi:"advanced,optional"` +} + +// Annotate provides SDK documentation for KedaScaledObjectArgs fields. +func (k *KedaScaledObjectArgs) Annotate(a infer.Annotator) { + a.Describe(&k.Triggers, "KEDA scaler triggers driving this ScaledObject.") + a.Describe(&k.MinReplicaCount, "Minimum number of replicas. Example: 0.") + a.Describe(&k.MaxReplicaCount, "Maximum number of replicas. Example: 10.") + a.Describe(&k.IdleReplicaCount, "Replica count to scale to when idle. Must be less than minReplicaCount. Example: 0.") + a.Describe(&k.PollingInterval, "Seconds between checks of trigger metrics. Example: 30.") + a.Describe(&k.CooldownPeriod, "Seconds to wait after the last trigger reports active=false before scaling to minReplicaCount. Example: 300.") + a.Describe(&k.InitialCooldownPeriod, "Cooldown period applied only during the initial scaling of the ScaledObject. Example: 0.") + a.Describe(&k.Fallback, "Replica fallback configuration when KEDA metrics are unavailable.") + a.Describe(&k.Advanced, "Advanced ScaledObject behavior configuration.") +} + // ContainerResourceRuleConfigArgs holds per-container resource rules. type ContainerResourceRuleConfigArgs struct { ContainerName string `pulumi:"containerName"` @@ -194,28 +302,32 @@ func (c *ContainerResourceRuleConfigArgs) Annotate(a infer.Annotator) { // WorkloadRuleArgs are the user-configurable inputs for a WorkloadRule resource. type WorkloadRuleArgs struct { - ClusterID string `pulumi:"clusterId"` - Namespace string `pulumi:"namespace"` - Kind string `pulumi:"kind"` - Name string `pulumi:"name"` - AutoGenerate *bool `pulumi:"autoGenerate,optional"` - CpuRule *ResourceRuleConfigArgs `pulumi:"cpuRule,optional"` - MemoryRule *ResourceRuleConfigArgs `pulumi:"memoryRule,optional"` - GpuRule *ResourceRuleConfigArgs `pulumi:"gpuRule,optional"` - HpaRule *HPARuleConfigArgs `pulumi:"hpaRule,optional"` - EmergencyResponse *EmergencyResponseConfigArgs `pulumi:"emergencyResponse,optional"` - ActionTriggers []string `pulumi:"actionTriggers,optional"` - StartupPeriodSeconds *int `pulumi:"startupPeriodSeconds,optional"` - CronSchedule *string `pulumi:"cronSchedule,optional"` - CooldownMinutes *int `pulumi:"cooldownMinutes,optional"` - DetectionTriggers []string `pulumi:"detectionTriggers,optional"` - SchedulerPlugins []string `pulumi:"schedulerPlugins,optional"` - DefragmentationSchedule *string `pulumi:"defragmentationSchedule,optional"` - LiveMigrationEnabled bool `pulumi:"liveMigrationEnabled,optional"` - UseInPlaceVerticalScaling bool `pulumi:"useInPlaceVerticalScaling,optional"` - Containers []ContainerResourceRuleConfigArgs `pulumi:"containers,optional"` - Disabled *bool `pulumi:"disabled,optional"` - LookbackPeriodSeconds *int `pulumi:"lookbackPeriodSeconds,optional"` + ClusterID string `pulumi:"clusterId"` + Namespace string `pulumi:"namespace"` + Kind string `pulumi:"kind"` + Name string `pulumi:"name"` + AutoGenerate *bool `pulumi:"autoGenerate,optional"` + CpuRule *ResourceRuleConfigArgs `pulumi:"cpuRule,optional"` + MemoryRule *ResourceRuleConfigArgs `pulumi:"memoryRule,optional"` + GpuRule *ResourceRuleConfigArgs `pulumi:"gpuRule,optional"` + HpaRule *HPARuleConfigArgs `pulumi:"hpaRule,optional"` + EmergencyResponse *EmergencyResponseConfigArgs `pulumi:"emergencyResponse,optional"` + ActionTriggers []string `pulumi:"actionTriggers,optional"` + StartupPeriodSeconds *int `pulumi:"startupPeriodSeconds,optional"` + CronSchedule *string `pulumi:"cronSchedule,optional"` + CooldownMinutes *int `pulumi:"cooldownMinutes,optional"` + DetectionTriggers []string `pulumi:"detectionTriggers,optional"` + SchedulerPlugins []string `pulumi:"schedulerPlugins,optional"` + DefragmentationSchedule *string `pulumi:"defragmentationSchedule,optional"` + LiveMigrationEnabled bool `pulumi:"liveMigrationEnabled,optional"` + UseInPlaceVerticalScaling bool `pulumi:"useInPlaceVerticalScaling,optional"` + Containers []ContainerResourceRuleConfigArgs `pulumi:"containers,optional"` + Disabled *bool `pulumi:"disabled,optional"` + LookbackPeriodSeconds *int `pulumi:"lookbackPeriodSeconds,optional"` + AllowInPlaceMemoryLimitDecrease bool `pulumi:"allowInPlaceMemoryLimitDecrease,optional"` + JvmHeapRule *JvmHeapRuleConfigArgs `pulumi:"jvmHeapRule,optional"` + JvmCpuStartupFloorMillicores *int `pulumi:"jvmCpuStartupFloorMillicores,optional"` + KedaScaledObject *KedaScaledObjectArgs `pulumi:"kedaScaledObject,optional"` } // Annotate provides SDK documentation for WorkloadRuleArgs fields. @@ -240,6 +352,10 @@ func (a *WorkloadRuleArgs) Annotate(ann infer.Annotator) { ann.Describe(&a.LiveMigrationEnabled, "Allow live pod migration when applying recommendations. Example: false.") ann.Describe(&a.UseInPlaceVerticalScaling, "Use in-place pod vertical scaling instead of pod restarts. Example: false.") ann.Describe(&a.Containers, "Per-container resource rule configurations. When empty, workload-level rules apply to all containers.") + ann.Describe(&a.AllowInPlaceMemoryLimitDecrease, "Allow in-place vertical scaling to decrease the memory limit (normally only requests shrink; limits only grow). Example: false.") + ann.Describe(&a.JvmHeapRule, "JVM heap sizing overrides applied to detected Java containers.") + ann.Describe(&a.JvmCpuStartupFloorMillicores, "Minimum CPU request in millicores during JVM startup, to avoid slow JIT warmup on undersized CPU. Example: 500.") + ann.Describe(&a.KedaScaledObject, "KEDA ScaledObject configuration managed alongside this workload.") } // WorkloadRuleState is the full persisted state. @@ -449,17 +565,24 @@ func ruleArgsToUpsertRequest(teamID string, a WorkloadRuleArgs, includeDisabled return req } req.Fields = &apiv1.ManualRuleFields{ - CpuRule: resourceRuleConfigToProto(a.CpuRule), - MemoryRule: resourceRuleConfigToProto(a.MemoryRule), - GpuRule: resourceRuleConfigToProto(a.GpuRule), - HpaRule: hpaRuleConfigToProto(a.HpaRule), - EmergencyResponse: emergencyResponseToProto(a.EmergencyResponse), - ActionTriggers: actionTriggersToProto(a.ActionTriggers), - DetectionTriggers: detectionTriggersToProto(a.DetectionTriggers), - SchedulerPlugins: a.SchedulerPlugins, - LiveMigrationEnabled: a.LiveMigrationEnabled, - UseInPlaceVerticalScaling: a.UseInPlaceVerticalScaling, - Containers: containerRuleConfigsToProto(a.Containers), + CpuRule: resourceRuleConfigToProto(a.CpuRule), + MemoryRule: resourceRuleConfigToProto(a.MemoryRule), + GpuRule: resourceRuleConfigToProto(a.GpuRule), + HpaRule: hpaRuleConfigToProto(a.HpaRule), + EmergencyResponse: emergencyResponseToProto(a.EmergencyResponse), + ActionTriggers: actionTriggersToProto(a.ActionTriggers), + DetectionTriggers: detectionTriggersToProto(a.DetectionTriggers), + SchedulerPlugins: a.SchedulerPlugins, + LiveMigrationEnabled: a.LiveMigrationEnabled, + UseInPlaceVerticalScaling: a.UseInPlaceVerticalScaling, + Containers: containerRuleConfigsToProto(a.Containers), + AllowInPlaceMemoryLimitDecrease: a.AllowInPlaceMemoryLimitDecrease, + JvmHeapRule: jvmHeapRuleToProto(a.JvmHeapRule), + KedaScaledObject: kedaScaledObjectToProto(a.KedaScaledObject), + } + if a.JvmCpuStartupFloorMillicores != nil { + v := int64(*a.JvmCpuStartupFloorMillicores) + req.Fields.JvmCpuStartupFloorMillicores = &v } if a.StartupPeriodSeconds != nil { v := int64(*a.StartupPeriodSeconds) @@ -487,21 +610,28 @@ func ruleArgsToUpsertRequest(teamID string, a WorkloadRuleArgs, includeDisabled func ruleProtoToArgs(r *apiv1.WorkloadRule) WorkloadRuleArgs { a := WorkloadRuleArgs{ - ClusterID: r.ClusterId, - Namespace: r.Namespace, - Kind: r.Kind, - Name: r.Name, - CpuRule: resourceRuleConfigFromProto(r.CpuRule), - MemoryRule: resourceRuleConfigFromProto(r.MemoryRule), - GpuRule: resourceRuleConfigFromProto(r.GpuRule), - HpaRule: hpaRuleConfigFromProto(r.HpaRule), - EmergencyResponse: emergencyResponseFromProto(r.EmergencyResponse), - ActionTriggers: actionTriggersFromProto(r.ActionTriggers), - DetectionTriggers: detectionTriggersFromProto(r.DetectionTriggers), - SchedulerPlugins: r.SchedulerPlugins, - LiveMigrationEnabled: r.LiveMigrationEnabled, - UseInPlaceVerticalScaling: r.UseInPlaceVerticalScaling, - Containers: containerRuleConfigsFromProto(r.Containers), + ClusterID: r.ClusterId, + Namespace: r.Namespace, + Kind: r.Kind, + Name: r.Name, + CpuRule: resourceRuleConfigFromProto(r.CpuRule), + MemoryRule: resourceRuleConfigFromProto(r.MemoryRule), + GpuRule: resourceRuleConfigFromProto(r.GpuRule), + HpaRule: hpaRuleConfigFromProto(r.HpaRule), + EmergencyResponse: emergencyResponseFromProto(r.EmergencyResponse), + ActionTriggers: actionTriggersFromProto(r.ActionTriggers), + DetectionTriggers: detectionTriggersFromProto(r.DetectionTriggers), + SchedulerPlugins: r.SchedulerPlugins, + LiveMigrationEnabled: r.LiveMigrationEnabled, + UseInPlaceVerticalScaling: r.UseInPlaceVerticalScaling, + Containers: containerRuleConfigsFromProto(r.Containers), + AllowInPlaceMemoryLimitDecrease: r.AllowInPlaceMemoryLimitDecrease, + JvmHeapRule: jvmHeapRuleFromProto(r.JvmHeapRule), + KedaScaledObject: kedaScaledObjectFromProto(r.KedaScaledObject), + } + if r.JvmCpuStartupFloorMillicores != nil { + v := int(*r.JvmCpuStartupFloorMillicores) + a.JvmCpuStartupFloorMillicores = &v } if r.Disabled { a.Disabled = truePtr() @@ -978,3 +1108,246 @@ func containerResourceConfigFromProto(p *apiv1.ContainerResourceConfig) *Resourc r.LimitUseRss = p.LimitUseRss return r } + +func jvmHeapRuleToProto(j *JvmHeapRuleConfigArgs) *apiv1.JVMHeapRuleConfig { + if j == nil { + return nil + } + p := &apiv1.JVMHeapRuleConfig{ + Enabled: j.Enabled, + PreferContainerSupport: j.PreferContainerSupport, + } + if j.TargetPercentile != nil { + v := float32(*j.TargetPercentile) + p.TargetPercentile = &v + } + if j.HeadroomMultiplier != nil { + v := float32(*j.HeadroomMultiplier) + p.HeadroomMultiplier = &v + } + if j.NonHeapOverheadPercent != nil { + v := float32(*j.NonHeapOverheadPercent) + p.NonHeapOverheadPercent = &v + } + if j.NonHeapOverheadBytes != nil { + v := int64(*j.NonHeapOverheadBytes) + p.NonHeapOverheadBytes = &v + } + if j.MinHeapBytes != nil { + v := int64(*j.MinHeapBytes) + p.MinHeapBytes = &v + } + if j.MaxHeapBytes != nil { + v := int64(*j.MaxHeapBytes) + p.MaxHeapBytes = &v + } + return p +} + +func jvmHeapRuleFromProto(p *apiv1.JVMHeapRuleConfig) *JvmHeapRuleConfigArgs { + if p == nil { + return nil + } + j := &JvmHeapRuleConfigArgs{ + Enabled: p.Enabled, + PreferContainerSupport: p.PreferContainerSupport, + } + if p.TargetPercentile != nil { + v := f32to64(*p.TargetPercentile) + j.TargetPercentile = &v + } + if p.HeadroomMultiplier != nil { + v := f32to64(*p.HeadroomMultiplier) + j.HeadroomMultiplier = &v + } + if p.NonHeapOverheadPercent != nil { + v := f32to64(*p.NonHeapOverheadPercent) + j.NonHeapOverheadPercent = &v + } + if p.NonHeapOverheadBytes != nil { + v := int(*p.NonHeapOverheadBytes) + j.NonHeapOverheadBytes = &v + } + if p.MinHeapBytes != nil { + v := int(*p.MinHeapBytes) + j.MinHeapBytes = &v + } + if p.MaxHeapBytes != nil { + v := int(*p.MaxHeapBytes) + j.MaxHeapBytes = &v + } + return j +} + +func kedaScaledObjectToProto(k *KedaScaledObjectArgs) *apiv1.KEDAScaledObjectTemplate { + if k == nil { + return nil + } + p := &apiv1.KEDAScaledObjectTemplate{ + Triggers: kedaTriggersToProto(k.Triggers), + Fallback: kedaFallbackToProto(k.Fallback), + Advanced: kedaAdvancedToProto(k.Advanced), + } + if k.MinReplicaCount != nil { + v := int32(*k.MinReplicaCount) + p.MinReplicaCount = &v + } + if k.MaxReplicaCount != nil { + v := int32(*k.MaxReplicaCount) + p.MaxReplicaCount = &v + } + if k.IdleReplicaCount != nil { + v := int32(*k.IdleReplicaCount) + p.IdleReplicaCount = &v + } + if k.PollingInterval != nil { + v := int32(*k.PollingInterval) + p.PollingInterval = &v + } + if k.CooldownPeriod != nil { + v := int32(*k.CooldownPeriod) + p.CooldownPeriod = &v + } + if k.InitialCooldownPeriod != nil { + v := int32(*k.InitialCooldownPeriod) + p.InitialCooldownPeriod = &v + } + return p +} + +func kedaScaledObjectFromProto(p *apiv1.KEDAScaledObjectTemplate) *KedaScaledObjectArgs { + if p == nil { + return nil + } + k := &KedaScaledObjectArgs{ + Triggers: kedaTriggersFromProto(p.Triggers), + Fallback: kedaFallbackFromProto(p.Fallback), + Advanced: kedaAdvancedFromProto(p.Advanced), + } + if p.MinReplicaCount != nil { + v := int(*p.MinReplicaCount) + k.MinReplicaCount = &v + } + if p.MaxReplicaCount != nil { + v := int(*p.MaxReplicaCount) + k.MaxReplicaCount = &v + } + if p.IdleReplicaCount != nil { + v := int(*p.IdleReplicaCount) + k.IdleReplicaCount = &v + } + if p.PollingInterval != nil { + v := int(*p.PollingInterval) + k.PollingInterval = &v + } + if p.CooldownPeriod != nil { + v := int(*p.CooldownPeriod) + k.CooldownPeriod = &v + } + if p.InitialCooldownPeriod != nil { + v := int(*p.InitialCooldownPeriod) + k.InitialCooldownPeriod = &v + } + return k +} + +func kedaTriggersToProto(ts []KedaTriggerArgs) []*apiv1.KEDATrigger { + if len(ts) == 0 { + return nil + } + result := make([]*apiv1.KEDATrigger, len(ts)) + for i, t := range ts { + result[i] = &apiv1.KEDATrigger{ + Type: t.Type, + Name: t.Name, + Metadata: t.Metadata, + MetricType: t.MetricType, + AuthenticationRef: kedaAuthenticationRefToProto(t.AuthenticationRef), + UseCachedMetrics: t.UseCachedMetrics, + } + } + return result +} + +func kedaTriggersFromProto(ps []*apiv1.KEDATrigger) []KedaTriggerArgs { + if len(ps) == 0 { + return nil + } + result := make([]KedaTriggerArgs, 0, len(ps)) + for _, p := range ps { + if p == nil { + continue + } + result = append(result, KedaTriggerArgs{ + Type: p.Type, + Name: p.Name, + Metadata: p.Metadata, + MetricType: p.MetricType, + AuthenticationRef: kedaAuthenticationRefFromProto(p.AuthenticationRef), + UseCachedMetrics: p.UseCachedMetrics, + }) + } + return result +} + +func kedaAuthenticationRefToProto(a *KedaAuthenticationRefArgs) *apiv1.KEDAAuthenticationRef { + if a == nil { + return nil + } + return &apiv1.KEDAAuthenticationRef{ + Name: a.Name, + Kind: a.Kind, + } +} + +func kedaAuthenticationRefFromProto(p *apiv1.KEDAAuthenticationRef) *KedaAuthenticationRefArgs { + if p == nil { + return nil + } + return &KedaAuthenticationRefArgs{ + Name: p.Name, + Kind: p.Kind, + } +} + +func kedaFallbackToProto(f *KedaFallbackArgs) *apiv1.KEDAFallback { + if f == nil { + return nil + } + return &apiv1.KEDAFallback{ + FailureThreshold: int32(f.FailureThreshold), + Replicas: int32(f.Replicas), + Behavior: f.Behavior, + } +} + +func kedaFallbackFromProto(p *apiv1.KEDAFallback) *KedaFallbackArgs { + if p == nil { + return nil + } + return &KedaFallbackArgs{ + FailureThreshold: int(p.FailureThreshold), + Replicas: int(p.Replicas), + Behavior: p.Behavior, + } +} + +func kedaAdvancedToProto(a *KedaAdvancedArgs) *apiv1.KEDAAdvanced { + if a == nil { + return nil + } + return &apiv1.KEDAAdvanced{ + RestoreToOriginalReplicaCount: a.RestoreToOriginalReplicaCount, + AdvancedBehaviorJson: a.AdvancedBehaviorJson, + } +} + +func kedaAdvancedFromProto(p *apiv1.KEDAAdvanced) *KedaAdvancedArgs { + if p == nil { + return nil + } + return &KedaAdvancedArgs{ + RestoreToOriginalReplicaCount: p.RestoreToOriginalReplicaCount, + AdvancedBehaviorJson: p.AdvancedBehaviorJson, + } +} From e1073c82590eee35382e3ebb891d69e9dd92f4bf Mon Sep 17 00:00:00 2001 From: Rupam-It Date: Wed, 26 Aug 2026 20:10:55 +0530 Subject: [PATCH 4/6] feat(workload_policy): add emergencyResponse field Signed-off-by: Rupam-It --- provider/pkg/resources/workload_policy.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/provider/pkg/resources/workload_policy.go b/provider/pkg/resources/workload_policy.go index 425aade..320aef3 100644 --- a/provider/pkg/resources/workload_policy.go +++ b/provider/pkg/resources/workload_policy.go @@ -126,6 +126,8 @@ type WorkloadPolicyArgs struct { JvmMaxHeapBytes *int `pulumi:"jvmMaxHeapBytes,optional"` JvmPreferContainerSupport *bool `pulumi:"jvmPreferContainerSupport,optional"` JvmCpuStartupFloorMillicores *int `pulumi:"jvmCpuStartupFloorMillicores,optional"` + + EmergencyResponse *EmergencyResponseConfigArgs `pulumi:"emergencyResponse,optional"` } // Annotate provides SDK documentation and default values for WorkloadPolicyArgs fields. @@ -152,6 +154,7 @@ func (a *WorkloadPolicyArgs) Annotate(ann infer.Annotator) { ann.Describe(&a.GpuVramVerticalScaling, "Vertical scaling configuration for GPU VRAM. Uses the same fields as cpuVerticalScaling; units are bytes.") ann.Describe(&a.EnablePmaxProtection, "Raise requests to cover observed peak usage when the peak/recommendation ratio exceeds pmaxRatioThreshold. Default: false.") ann.Describe(&a.PmaxRatioThreshold, "Peak-to-recommendation ratio above which pmax protection activates. Example: 3.0 (default) — triggers when peak is 3× the recommendation.") + ann.Describe(&a.EmergencyResponse, "Emergency response configuration for OOM and CPU throttle events.") ann.SetDefault(&a.PmaxRatioThreshold, 3.0) ann.SetDefault(&a.LoopbackPeriodSeconds, 86400) ann.SetDefault(&a.MinDataPoints, 15) @@ -294,6 +297,7 @@ func argsToProto(teamID, policyID string, a WorkloadPolicyArgs) *apiv1.WorkloadR GpuVerticalScaling: verticalScalingToProto(a.GpuVerticalScaling), GpuVramVerticalScaling: verticalScalingToProto(a.GpuVramVerticalScaling), HorizontalScaling: horizontalScalingToProto(a.HorizontalScaling), + EmergencyResponse: emergencyResponseToProto(a.EmergencyResponse), } if a.Description != nil { p.Description = *a.Description @@ -428,6 +432,7 @@ func protoToArgs(p *apiv1.WorkloadRecommendationPolicy) WorkloadPolicyArgs { GpuVerticalScaling: verticalScalingFromProto(p.GpuVerticalScaling), GpuVramVerticalScaling: verticalScalingFromProto(p.GpuVramVerticalScaling), HorizontalScaling: horizontalScalingFromProto(p.HorizontalScaling), + EmergencyResponse: emergencyResponseFromProto(p.EmergencyResponse), } if p.Description != "" { a.Description = &p.Description From 621b08888475ace63a96ad03d900bfbfeb464722 Mon Sep 17 00:00:00 2001 From: Rupam-It Date: Wed, 26 Aug 2026 20:11:43 +0530 Subject: [PATCH 5/6] chore(schema/sdk): regenerate schema.json and SDKs for new fields Signed-off-by: Rupam-It --- schema.json | 519 ++- sdk/go/devzero/resources/cluster.go | 4 +- sdk/go/devzero/resources/nodePolicy.go | 54 + sdk/go/devzero/resources/pulumiTypes.go | 4029 ++++++++++++++--- sdk/go/devzero/resources/workloadPolicy.go | 21 +- sdk/go/devzero/resources/workloadRule.go | 44 + sdk/nodejs/resources/cluster.ts | 2 +- sdk/nodejs/resources/nodePolicy.ts | 42 + sdk/nodejs/resources/workloadPolicy.ts | 10 + sdk/nodejs/resources/workloadRule.ts | 40 + sdk/nodejs/types/input.ts | 348 ++ sdk/nodejs/types/output.ts | 348 ++ .../pulumi_devzero/resources/_inputs.py | 2298 ++++++++-- .../pulumi_devzero/resources/cluster.py | 2 +- .../pulumi_devzero/resources/node_policy.py | 144 + .../pulumi_devzero/resources/outputs.py | 1774 +++++++- .../resources/workload_policy.py | 29 + .../pulumi_devzero/resources/workload_rule.py | 116 + 18 files changed, 8723 insertions(+), 1101 deletions(-) diff --git a/schema.json b/schema.json index 38a25fe..811c88b 100644 --- a/schema.json +++ b/schema.json @@ -501,6 +501,96 @@ }, "type": "object" }, + "devzero:resources:GCPDiskArgs": { + "properties": { + "boot": { + "type": "boolean", + "description": "Whether this disk is the boot disk. Example: true." + }, + "category": { + "type": "string", + "description": "GCP disk type. Example: 'pd-ssd'." + }, + "secondaryBootImage": { + "type": "string", + "description": "Secondary boot image used for container-image fast boot. Example: 'projects/my-project/global/images/my-cache-image'." + }, + "secondaryBootMode": { + "type": "string", + "description": "Secondary boot mode. Example: 'CONTAINER_IMAGE_CACHE'." + }, + "sizeGib": { + "type": "integer", + "description": "Disk size in GiB. Example: 100." + } + }, + "type": "object" + }, + "devzero:resources:GCPImageSelectorTermArgs": { + "properties": { + "alias": { + "type": "string", + "description": "Well-known alias for the GCP node image family. Example: 'cos@latest'." + }, + "id": { + "type": "string", + "description": "Explicit GCP image ID. Example: 'projects/cos-cloud/global/images/cos-105-17412-156-59'." + } + }, + "type": "object" + }, + "devzero:resources:GCPNodeClassSpecArgs": { + "properties": { + "disks": { + "type": "array", + "items": { + "$ref": "#/types/devzero:resources:GCPDiskArgs" + }, + "description": "Disks attached to provisioned nodes. Example: [{sizeGib: 100, category: \"pd-ssd\", boot: true}]." + }, + "imageFamily": { + "type": "string", + "description": "GCP node image family shorthand used when no imageSelectorTerms are specified. Example: 'cos'." + }, + "imageSelectorTerms": { + "type": "array", + "items": { + "$ref": "#/types/devzero:resources:GCPImageSelectorTermArgs" + }, + "description": "Selectors for the node images used to launch nodes. Example: [{alias: \"cos@latest\"}]." + }, + "kubelet": { + "$ref": "#/types/devzero:resources:KubeletConfigurationArgs", + "description": "Kubelet configuration overrides applied to all nodes in this class." + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "GCP labels applied to all resources created by this node class. Example: {\"environment\": \"production\"}." + }, + "metadata": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "GCE instance metadata applied to provisioned nodes. Example: {\"disable-legacy-endpoints\": \"true\"}." + }, + "networkTags": { + "type": "array", + "items": { + "type": "string" + }, + "description": "GCP network tags applied to provisioned nodes for firewall targeting. Example: [\"karpenter-node\"]." + }, + "serviceAccount": { + "type": "string", + "description": "GCP service account email attached to provisioned nodes. Example: 'karpenter@my-project.iam.gserviceaccount.com'." + } + }, + "type": "object" + }, "devzero:resources:HPABehaviorArgs": { "properties": { "scaleDown": { @@ -714,6 +804,172 @@ }, "type": "object" }, + "devzero:resources:JvmHeapRuleConfigArgs": { + "properties": { + "enabled": { + "type": "boolean", + "description": "Enable JVM heap sizing overrides. Example: true." + }, + "headroomMultiplier": { + "type": "number", + "description": "Multiplier applied above the target usage to derive the heap size. Example: 1.3." + }, + "maxHeapBytes": { + "type": "integer", + "description": "Maximum JVM heap size in bytes. Example: 2147483648." + }, + "minHeapBytes": { + "type": "integer", + "description": "Minimum JVM heap size in bytes. Example: 134217728." + }, + "nonHeapOverheadBytes": { + "type": "integer", + "description": "Non-heap memory overhead in bytes. Takes precedence over nonHeapOverheadPercent when set. Example: 268435456." + }, + "nonHeapOverheadPercent": { + "type": "number", + "description": "Non-heap memory overhead as a percentage of container memory (0-1). Example: 0.2." + }, + "preferContainerSupport": { + "type": "boolean", + "description": "Prefer the JVM's native container-aware heap sizing (-XX:+UseContainerSupport) over explicit -Xmx/-Xms flags. Example: false." + }, + "targetPercentile": { + "type": "number", + "description": "Percentile of usage data used as the heap sizing target (0-1). Example: 0.95." + } + }, + "type": "object" + }, + "devzero:resources:KedaAdvancedArgs": { + "properties": { + "advancedBehaviorJson": { + "type": "string", + "description": "Kubernetes HorizontalPodAutoscalerBehavior encoded as a JSON string, applied to the generated HPA. Example: '{\"scaleDown\":{\"stabilizationWindowSeconds\":300}}'." + }, + "restoreToOriginalReplicaCount": { + "type": "boolean", + "description": "Restore the original replica count when the ScaledObject is deleted. Example: false." + } + }, + "type": "object" + }, + "devzero:resources:KedaAuthenticationRefArgs": { + "properties": { + "kind": { + "type": "string", + "description": "Kind of the referenced resource. One of: 'TriggerAuthentication', 'ClusterTriggerAuthentication'. Example: 'TriggerAuthentication'." + }, + "name": { + "type": "string", + "description": "Name of the referenced TriggerAuthentication/ClusterTriggerAuthentication resource. Example: 'prometheus-auth'." + } + }, + "type": "object", + "required": [ + "name" + ] + }, + "devzero:resources:KedaFallbackArgs": { + "properties": { + "behavior": { + "type": "string", + "description": "Fallback strategy. Example: 'static'." + }, + "failureThreshold": { + "type": "integer", + "description": "Number of consecutive metric failures before activating fallback. Example: 3." + }, + "replicas": { + "type": "integer", + "description": "Number of replicas to fall back to when metrics are unavailable. Example: 2." + } + }, + "type": "object", + "required": [ + "failureThreshold", + "replicas" + ] + }, + "devzero:resources:KedaScaledObjectArgs": { + "properties": { + "advanced": { + "$ref": "#/types/devzero:resources:KedaAdvancedArgs", + "description": "Advanced ScaledObject behavior configuration." + }, + "cooldownPeriod": { + "type": "integer", + "description": "Seconds to wait after the last trigger reports active=false before scaling to minReplicaCount. Example: 300." + }, + "fallback": { + "$ref": "#/types/devzero:resources:KedaFallbackArgs", + "description": "Replica fallback configuration when KEDA metrics are unavailable." + }, + "idleReplicaCount": { + "type": "integer", + "description": "Replica count to scale to when idle. Must be less than minReplicaCount. Example: 0." + }, + "initialCooldownPeriod": { + "type": "integer", + "description": "Cooldown period applied only during the initial scaling of the ScaledObject. Example: 0." + }, + "maxReplicaCount": { + "type": "integer", + "description": "Maximum number of replicas. Example: 10." + }, + "minReplicaCount": { + "type": "integer", + "description": "Minimum number of replicas. Example: 0." + }, + "pollingInterval": { + "type": "integer", + "description": "Seconds between checks of trigger metrics. Example: 30." + }, + "triggers": { + "type": "array", + "items": { + "$ref": "#/types/devzero:resources:KedaTriggerArgs" + }, + "description": "KEDA scaler triggers driving this ScaledObject." + } + }, + "type": "object" + }, + "devzero:resources:KedaTriggerArgs": { + "properties": { + "authenticationRef": { + "$ref": "#/types/devzero:resources:KedaAuthenticationRefArgs", + "description": "Reference to a TriggerAuthentication or ClusterTriggerAuthentication for this trigger." + }, + "metadata": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Scaler-specific configuration key-value pairs. Example: {\"serverAddress\": \"http://prometheus:9090\", \"query\": \"sum(rate(http_requests_total[2m]))\"}." + }, + "metricType": { + "type": "string", + "description": "Metric target type. One of: 'Value', 'AverageValue', 'Utilization'. Example: 'AverageValue'." + }, + "name": { + "type": "string", + "description": "Optional trigger name, used to disambiguate multiple triggers of the same type. Example: 'requests-per-second'." + }, + "type": { + "type": "string", + "description": "KEDA scaler type. Example: 'prometheus'." + }, + "useCachedMetrics": { + "type": "boolean", + "description": "Use KEDA's metric caching for this trigger. Example: false." + } + }, + "type": "object", + "required": [ + "type" + ] + }, "devzero:resources:KubeletConfigurationArgs": { "properties": { "clusterDns": { @@ -864,6 +1120,185 @@ }, "type": "object" }, + "devzero:resources:OCIBootConfigArgs": { + "properties": { + "bootVolumeSizeInGbs": { + "type": "integer", + "description": "Boot volume size in GB. Example: 100." + }, + "bootVolumeVpusPerGb": { + "type": "integer", + "description": "Boot volume performance units per GB. Example: 10." + } + }, + "type": "object" + }, + "devzero:resources:OCIImageSelectorTermArgs": { + "properties": { + "compartmentId": { + "type": "string", + "description": "OCID of the compartment containing the image. Example: 'ocid1.compartment.oc1..aaaaaaaa'." + }, + "id": { + "type": "string", + "description": "Explicit OCI image OCID. Example: 'ocid1.image.oc1..aaaaaaaa'." + }, + "name": { + "type": "string", + "description": "OCI image display name filter. Example: 'Oracle-Linux-8.9'." + } + }, + "type": "object" + }, + "devzero:resources:OCILaunchOptionsArgs": { + "properties": { + "bootVolumeType": { + "type": "string", + "description": "Emulation type for the boot volume. Example: 'PARAVIRTUALIZED'." + }, + "firmware": { + "type": "string", + "description": "Firmware used to boot the instance. Example: 'UEFI_64'." + }, + "isConsistentVolumeNamingEnabled": { + "type": "boolean", + "description": "Whether consistent volume naming is enabled for the instance. Example: true." + }, + "networkType": { + "type": "string", + "description": "Emulation type for the network interface. Example: 'PARAVIRTUALIZED'." + }, + "remoteDataVolumeType": { + "type": "string", + "description": "Emulation type for remote data volumes. Example: 'PARAVIRTUALIZED'." + } + }, + "type": "object" + }, + "devzero:resources:OCINodeClassSpecArgs": { + "properties": { + "agentList": { + "type": "array", + "items": { + "type": "string" + }, + "description": "OCI compute instance agent plugins to enable. Example: [\"Compute Instance Monitoring\"]." + }, + "blockDevices": { + "type": "array", + "items": { + "$ref": "#/types/devzero:resources:OCIVolumeAttributesArgs" + }, + "description": "Additional block volumes attached to provisioned nodes." + }, + "bootConfig": { + "$ref": "#/types/devzero:resources:OCIBootConfigArgs", + "description": "Boot volume configuration for provisioned nodes." + }, + "freeFormTags": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "OCI free-form tags applied to all resources created by this node class. Example: {\"environment\": \"production\"}." + }, + "imageFamily": { + "type": "string", + "description": "OCI node image family shorthand used when no imageSelector is specified. Example: 'Oracle-Linux-8'." + }, + "imageSelector": { + "type": "array", + "items": { + "$ref": "#/types/devzero:resources:OCIImageSelectorTermArgs" + }, + "description": "Selectors for the images used to launch nodes. Example: [{name: \"Oracle-Linux-8.9\"}]." + }, + "launchOptions": { + "$ref": "#/types/devzero:resources:OCILaunchOptionsArgs", + "description": "Instance launch options controlling firmware and network/volume emulation type." + }, + "metaData": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "OCI instance metadata applied to provisioned nodes. Example: {\"ssh_authorized_keys\": \"ssh-rsa ...\"}." + }, + "preInstallScript": { + "type": "string", + "description": "Script executed before node bootstrap. Example: '#!/bin/bash\\necho pre-install'." + }, + "securityGroupSelector": { + "type": "array", + "items": { + "$ref": "#/types/devzero:resources:OCISecurityGroupSelectorTermArgs" + }, + "description": "Selectors for network security groups attached to provisioned nodes." + }, + "subnetSelector": { + "type": "array", + "items": { + "$ref": "#/types/devzero:resources:OCISubnetSelectorTermArgs" + }, + "description": "Selectors for the subnets nodes will be launched into." + }, + "tags": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "OCI defined tags applied to all resources created by this node class." + }, + "userData": { + "type": "string", + "description": "Custom cloud-init user data merged into the node launch config (base64 or plain text). Example: '#!/bin/bash\\necho hello'." + }, + "vcnId": { + "type": "string", + "description": "OCID of the VCN nodes will be launched into. Example: 'ocid1.vcn.oc1..aaaaaaaa'." + } + }, + "type": "object" + }, + "devzero:resources:OCISecurityGroupSelectorTermArgs": { + "properties": { + "id": { + "type": "string", + "description": "Explicit OCI network security group OCID. Example: 'ocid1.networksecuritygroup.oc1..aaaaaaaa'." + }, + "name": { + "type": "string", + "description": "OCI network security group display name filter. Example: 'node-nsg'." + } + }, + "type": "object" + }, + "devzero:resources:OCISubnetSelectorTermArgs": { + "properties": { + "id": { + "type": "string", + "description": "Explicit OCI subnet OCID. Example: 'ocid1.subnet.oc1..aaaaaaaa'." + }, + "name": { + "type": "string", + "description": "OCI subnet display name filter. Example: 'node-subnet'." + } + }, + "type": "object" + }, + "devzero:resources:OCIVolumeAttributesArgs": { + "properties": { + "sizeInGbs": { + "type": "integer", + "description": "Block volume size in GB. Example: 50." + }, + "vpusPerGb": { + "type": "integer", + "description": "Block volume performance units per GB. Example: 10." + } + }, + "type": "object" + }, "devzero:resources:RawKarpenterSpecArgs": { "properties": { "nodeclassYaml": { @@ -1103,7 +1538,7 @@ }, "token": { "type": "string", - "description": "Authentication token for the cluster. Rotated automatically if empty on update (e.g. after import).", + "description": "Bearer token minted for the cluster at creation. Not retrievable afterwards; imported clusters have an empty token (rotate it deliberately from the DevZero UI if you need it in state).", "secret": true } }, @@ -1149,6 +1584,10 @@ "$ref": "#/types/devzero:resources:DisruptionPolicyArgs", "description": "Karpenter disruption policy controlling consolidation, expiry, and budgets." }, + "gcp": { + "$ref": "#/types/devzero:resources:GCPNodeClassSpecArgs", + "description": "GCP-specific GCENodeClass configuration (service account, images, disks, etc.)." + }, "instanceCategories": { "$ref": "#/types/devzero:resources:LabelSelectorArgs", "description": "Filter instances by category letter (cloud-specific). Example: {in: [\"m\", \"c\", \"r\"]} for AWS, {in: [\"D\", \"E\"]} for Azure." @@ -1172,6 +1611,18 @@ "instanceLocalNvme": { "$ref": "#/types/devzero:resources:LabelSelectorArgs" }, + "instanceLocalNvmeTip": { + "type": "string", + "description": "UI tooltip text shown alongside the instanceLocalNvme selector." + }, + "instanceShapes": { + "$ref": "#/types/devzero:resources:LabelSelectorArgs", + "description": "GCP-only: filter by standard/highcpu/highmem custom shape token. Example: {in: [\"standard\", \"highmem\"]}." + }, + "instanceShapesTip": { + "type": "string", + "description": "UI tooltip text shown alongside the instanceShapes selector." + }, "instanceSizes": { "$ref": "#/types/devzero:resources:LabelSelectorArgs", "description": "Filter instances by size label. Example: {in: [\"large\", \"xlarge\", \"2xlarge\"]}." @@ -1206,6 +1657,10 @@ "type": "string", "description": "Override name for the generated Karpenter NodePool resource. Example: 'prod-spot-nodepool'." }, + "oci": { + "$ref": "#/types/devzero:resources:OCINodeClassSpecArgs", + "description": "OCI-specific NodeClass configuration (VCN, subnets, images, block volumes, etc.)." + }, "operatingSystems": { "$ref": "#/types/devzero:resources:LabelSelectorArgs", "description": "Operating systems for nodes. Example: {in: [\"linux\"]}." @@ -1223,6 +1678,10 @@ "$ref": "#/types/devzero:resources:TaintArgs" } }, + "startupTaintsTip": { + "type": "string", + "description": "UI tooltip text shown alongside startupTaints." + }, "taints": { "type": "array", "items": { @@ -1267,6 +1726,9 @@ "disruption": { "$ref": "#/types/devzero:resources:DisruptionPolicyArgs" }, + "gcp": { + "$ref": "#/types/devzero:resources:GCPNodeClassSpecArgs" + }, "instanceCategories": { "$ref": "#/types/devzero:resources:LabelSelectorArgs" }, @@ -1285,6 +1747,15 @@ "instanceLocalNvme": { "$ref": "#/types/devzero:resources:LabelSelectorArgs" }, + "instanceLocalNvmeTip": { + "type": "string" + }, + "instanceShapes": { + "$ref": "#/types/devzero:resources:LabelSelectorArgs" + }, + "instanceShapesTip": { + "type": "string" + }, "instanceSizes": { "$ref": "#/types/devzero:resources:LabelSelectorArgs" }, @@ -1312,6 +1783,9 @@ "nodePoolName": { "type": "string" }, + "oci": { + "$ref": "#/types/devzero:resources:OCINodeClassSpecArgs" + }, "operatingSystems": { "$ref": "#/types/devzero:resources:LabelSelectorArgs" }, @@ -1327,6 +1801,9 @@ "$ref": "#/types/devzero:resources:TaintArgs" } }, + "startupTaintsTip": { + "type": "string" + }, "taints": { "type": "array", "items": { @@ -1460,6 +1937,10 @@ "type": "number", "description": "Percentage change from the baseline recommendation that triggers a VPA refresh. Example: 20.0." }, + "emergencyResponse": { + "$ref": "#/types/devzero:resources:EmergencyResponseConfigArgs", + "description": "Emergency response configuration for OOM and CPU throttle events." + }, "enableInPlaceVerticalScaling": { "type": "boolean" }, @@ -1642,6 +2123,10 @@ "type": "number", "description": "Percentage change from the baseline recommendation that triggers a VPA refresh. Example: 20.0." }, + "emergencyResponse": { + "$ref": "#/types/devzero:resources:EmergencyResponseConfigArgs", + "description": "Emergency response configuration for OOM and CPU throttle events." + }, "enableInPlaceVerticalScaling": { "type": "boolean" }, @@ -1948,6 +2433,10 @@ }, "description": "When to apply recommendations. Valid values: 'on_detection', 'on_schedule'. Example: [\"on_detection\"]." }, + "allowInPlaceMemoryLimitDecrease": { + "type": "boolean", + "description": "Allow in-place vertical scaling to decrease the memory limit (normally only requests shrink; limits only grow). Example: false." + }, "autoGenerate": { "type": "boolean", "description": "When true the engine generates all rule fields automatically; manual field overrides are ignored. Example: false." @@ -2001,6 +2490,18 @@ "$ref": "#/types/devzero:resources:HPARuleConfigArgs", "description": "Horizontal (replica) scaling rule configuration." }, + "jvmCpuStartupFloorMillicores": { + "type": "integer", + "description": "Minimum CPU request in millicores during JVM startup, to avoid slow JIT warmup on undersized CPU. Example: 500." + }, + "jvmHeapRule": { + "$ref": "#/types/devzero:resources:JvmHeapRuleConfigArgs", + "description": "JVM heap sizing overrides applied to detected Java containers." + }, + "kedaScaledObject": { + "$ref": "#/types/devzero:resources:KedaScaledObjectArgs", + "description": "KEDA ScaledObject configuration managed alongside this workload." + }, "kind": { "type": "string", "description": "Kubernetes workload kind. One of: 'Deployment', 'StatefulSet', 'DaemonSet', 'CronJob', 'Job'. Example: 'Deployment'." @@ -2054,6 +2555,10 @@ }, "description": "When to apply recommendations. Valid values: 'on_detection', 'on_schedule'. Example: [\"on_detection\"]." }, + "allowInPlaceMemoryLimitDecrease": { + "type": "boolean", + "description": "Allow in-place vertical scaling to decrease the memory limit (normally only requests shrink; limits only grow). Example: false." + }, "autoGenerate": { "type": "boolean", "description": "When true the engine generates all rule fields automatically; manual field overrides are ignored. Example: false." @@ -2107,6 +2612,18 @@ "$ref": "#/types/devzero:resources:HPARuleConfigArgs", "description": "Horizontal (replica) scaling rule configuration." }, + "jvmCpuStartupFloorMillicores": { + "type": "integer", + "description": "Minimum CPU request in millicores during JVM startup, to avoid slow JIT warmup on undersized CPU. Example: 500." + }, + "jvmHeapRule": { + "$ref": "#/types/devzero:resources:JvmHeapRuleConfigArgs", + "description": "JVM heap sizing overrides applied to detected Java containers." + }, + "kedaScaledObject": { + "$ref": "#/types/devzero:resources:KedaScaledObjectArgs", + "description": "KEDA ScaledObject configuration managed alongside this workload." + }, "kind": { "type": "string", "description": "Kubernetes workload kind. One of: 'Deployment', 'StatefulSet', 'DaemonSet', 'CronJob', 'Job'. Example: 'Deployment'." diff --git a/sdk/go/devzero/resources/cluster.go b/sdk/go/devzero/resources/cluster.go index a453280..5b0016f 100644 --- a/sdk/go/devzero/resources/cluster.go +++ b/sdk/go/devzero/resources/cluster.go @@ -17,7 +17,7 @@ type Cluster struct { // The name of the cluster. Name pulumi.StringOutput `pulumi:"name"` - // Authentication token for the cluster. Rotated automatically if empty on update (e.g. after import). + // Bearer token minted for the cluster at creation. Not retrievable afterwards; imported clusters have an empty token (rotate it deliberately from the DevZero UI if you need it in state). Token pulumi.StringOutput `pulumi:"token"` } @@ -168,7 +168,7 @@ func (o ClusterOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v *Cluster) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) } -// Authentication token for the cluster. Rotated automatically if empty on update (e.g. after import). +// Bearer token minted for the cluster at creation. Not retrievable afterwards; imported clusters have an empty token (rotate it deliberately from the DevZero UI if you need it in state). func (o ClusterOutput) Token() pulumi.StringOutput { return o.ApplyT(func(v *Cluster) pulumi.StringOutput { return v.Token }).(pulumi.StringOutput) } diff --git a/sdk/go/devzero/resources/nodePolicy.go b/sdk/go/devzero/resources/nodePolicy.go index cb02731..d9196d2 100644 --- a/sdk/go/devzero/resources/nodePolicy.go +++ b/sdk/go/devzero/resources/nodePolicy.go @@ -28,6 +28,8 @@ type NodePolicy struct { Description pulumi.StringPtrOutput `pulumi:"description"` // Karpenter disruption policy controlling consolidation, expiry, and budgets. Disruption DisruptionPolicyArgsPtrOutput `pulumi:"disruption"` + // GCP-specific GCENodeClass configuration (service account, images, disks, etc.). + Gcp GCPNodeClassSpecArgsPtrOutput `pulumi:"gcp"` // Filter instances by category letter (cloud-specific). Example: {in: ["m", "c", "r"]} for AWS, {in: ["D", "E"]} for Azure. InstanceCategories LabelSelectorArgsPtrOutput `pulumi:"instanceCategories"` // Filter instances by vCPU count. Example: {in: ["4", "8", "16"]}. @@ -39,6 +41,12 @@ type NodePolicy struct { // Filter instances by hypervisor type. Example: {in: ["nitro"]}. InstanceHypervisors LabelSelectorArgsPtrOutput `pulumi:"instanceHypervisors"` InstanceLocalNvme LabelSelectorArgsPtrOutput `pulumi:"instanceLocalNvme"` + // UI tooltip text shown alongside the instanceLocalNvme selector. + InstanceLocalNvmeTip pulumi.StringPtrOutput `pulumi:"instanceLocalNvmeTip"` + // GCP-only: filter by standard/highcpu/highmem custom shape token. Example: {in: ["standard", "highmem"]}. + InstanceShapes LabelSelectorArgsPtrOutput `pulumi:"instanceShapes"` + // UI tooltip text shown alongside the instanceShapes selector. + InstanceShapesTip pulumi.StringPtrOutput `pulumi:"instanceShapesTip"` // Filter instances by size label. Example: {in: ["large", "xlarge", "2xlarge"]}. InstanceSizes LabelSelectorArgsPtrOutput `pulumi:"instanceSizes"` // Explicitly allow specific instance types. Example: {in: ["m5.large", "c6i.large"]}. @@ -54,11 +62,15 @@ type NodePolicy struct { NodeClassName pulumi.StringPtrOutput `pulumi:"nodeClassName"` // Override name for the generated Karpenter NodePool resource. Example: 'prod-spot-nodepool'. NodePoolName pulumi.StringPtrOutput `pulumi:"nodePoolName"` + // OCI-specific NodeClass configuration (VCN, subnets, images, block volumes, etc.). + Oci OCINodeClassSpecArgsPtrOutput `pulumi:"oci"` // Operating systems for nodes. Example: {in: ["linux"]}. OperatingSystems LabelSelectorArgsPtrOutput `pulumi:"operatingSystems"` // Raw Karpenter YAML for full NodePool/NodeClass customization — use only when structured fields are insufficient. Raw RawKarpenterSpecArgsArrayOutput `pulumi:"raw"` StartupTaints TaintArgsArrayOutput `pulumi:"startupTaints"` + // UI tooltip text shown alongside startupTaints. + StartupTaintsTip pulumi.StringPtrOutput `pulumi:"startupTaintsTip"` // Taints applied to provisioned nodes to control pod scheduling. Example: [{key: "dedicated", value: "gpu", effect: "NoSchedule"}]. Taints TaintArgsArrayOutput `pulumi:"taints"` // Priority weight; higher values take precedence when multiple policies match. Example: 100. @@ -118,12 +130,16 @@ type nodePolicyArgs struct { CloudProviderId *int `pulumi:"cloudProviderId"` Description *string `pulumi:"description"` Disruption *DisruptionPolicyArgs `pulumi:"disruption"` + Gcp *GCPNodeClassSpecArgs `pulumi:"gcp"` InstanceCategories *LabelSelectorArgs `pulumi:"instanceCategories"` InstanceCpus *LabelSelectorArgs `pulumi:"instanceCpus"` InstanceFamilies *LabelSelectorArgs `pulumi:"instanceFamilies"` InstanceGenerations *LabelSelectorArgs `pulumi:"instanceGenerations"` InstanceHypervisors *LabelSelectorArgs `pulumi:"instanceHypervisors"` InstanceLocalNvme *LabelSelectorArgs `pulumi:"instanceLocalNvme"` + InstanceLocalNvmeTip *string `pulumi:"instanceLocalNvmeTip"` + InstanceShapes *LabelSelectorArgs `pulumi:"instanceShapes"` + InstanceShapesTip *string `pulumi:"instanceShapesTip"` InstanceSizes *LabelSelectorArgs `pulumi:"instanceSizes"` InstanceTypes *LabelSelectorArgs `pulumi:"instanceTypes"` Labels map[string]string `pulumi:"labels"` @@ -132,9 +148,11 @@ type nodePolicyArgs struct { Name string `pulumi:"name"` NodeClassName *string `pulumi:"nodeClassName"` NodePoolName *string `pulumi:"nodePoolName"` + Oci *OCINodeClassSpecArgs `pulumi:"oci"` OperatingSystems *LabelSelectorArgs `pulumi:"operatingSystems"` Raw []RawKarpenterSpecArgs `pulumi:"raw"` StartupTaints []TaintArgs `pulumi:"startupTaints"` + StartupTaintsTip *string `pulumi:"startupTaintsTip"` Taints []TaintArgs `pulumi:"taints"` Weight *int `pulumi:"weight"` ZonalShift *ZonalShiftConfigArgs `pulumi:"zonalShift"` @@ -150,12 +168,16 @@ type NodePolicyArgs struct { CloudProviderId pulumi.IntPtrInput Description pulumi.StringPtrInput Disruption DisruptionPolicyArgsPtrInput + Gcp GCPNodeClassSpecArgsPtrInput InstanceCategories LabelSelectorArgsPtrInput InstanceCpus LabelSelectorArgsPtrInput InstanceFamilies LabelSelectorArgsPtrInput InstanceGenerations LabelSelectorArgsPtrInput InstanceHypervisors LabelSelectorArgsPtrInput InstanceLocalNvme LabelSelectorArgsPtrInput + InstanceLocalNvmeTip pulumi.StringPtrInput + InstanceShapes LabelSelectorArgsPtrInput + InstanceShapesTip pulumi.StringPtrInput InstanceSizes LabelSelectorArgsPtrInput InstanceTypes LabelSelectorArgsPtrInput Labels pulumi.StringMapInput @@ -164,9 +186,11 @@ type NodePolicyArgs struct { Name pulumi.StringInput NodeClassName pulumi.StringPtrInput NodePoolName pulumi.StringPtrInput + Oci OCINodeClassSpecArgsPtrInput OperatingSystems LabelSelectorArgsPtrInput Raw RawKarpenterSpecArgsArrayInput StartupTaints TaintArgsArrayInput + StartupTaintsTip pulumi.StringPtrInput Taints TaintArgsArrayInput Weight pulumi.IntPtrInput ZonalShift ZonalShiftConfigArgsPtrInput @@ -294,6 +318,11 @@ func (o NodePolicyOutput) Disruption() DisruptionPolicyArgsPtrOutput { return o.ApplyT(func(v *NodePolicy) DisruptionPolicyArgsPtrOutput { return v.Disruption }).(DisruptionPolicyArgsPtrOutput) } +// GCP-specific GCENodeClass configuration (service account, images, disks, etc.). +func (o NodePolicyOutput) Gcp() GCPNodeClassSpecArgsPtrOutput { + return o.ApplyT(func(v *NodePolicy) GCPNodeClassSpecArgsPtrOutput { return v.Gcp }).(GCPNodeClassSpecArgsPtrOutput) +} + // Filter instances by category letter (cloud-specific). Example: {in: ["m", "c", "r"]} for AWS, {in: ["D", "E"]} for Azure. func (o NodePolicyOutput) InstanceCategories() LabelSelectorArgsPtrOutput { return o.ApplyT(func(v *NodePolicy) LabelSelectorArgsPtrOutput { return v.InstanceCategories }).(LabelSelectorArgsPtrOutput) @@ -323,6 +352,21 @@ func (o NodePolicyOutput) InstanceLocalNvme() LabelSelectorArgsPtrOutput { return o.ApplyT(func(v *NodePolicy) LabelSelectorArgsPtrOutput { return v.InstanceLocalNvme }).(LabelSelectorArgsPtrOutput) } +// UI tooltip text shown alongside the instanceLocalNvme selector. +func (o NodePolicyOutput) InstanceLocalNvmeTip() pulumi.StringPtrOutput { + return o.ApplyT(func(v *NodePolicy) pulumi.StringPtrOutput { return v.InstanceLocalNvmeTip }).(pulumi.StringPtrOutput) +} + +// GCP-only: filter by standard/highcpu/highmem custom shape token. Example: {in: ["standard", "highmem"]}. +func (o NodePolicyOutput) InstanceShapes() LabelSelectorArgsPtrOutput { + return o.ApplyT(func(v *NodePolicy) LabelSelectorArgsPtrOutput { return v.InstanceShapes }).(LabelSelectorArgsPtrOutput) +} + +// UI tooltip text shown alongside the instanceShapes selector. +func (o NodePolicyOutput) InstanceShapesTip() pulumi.StringPtrOutput { + return o.ApplyT(func(v *NodePolicy) pulumi.StringPtrOutput { return v.InstanceShapesTip }).(pulumi.StringPtrOutput) +} + // Filter instances by size label. Example: {in: ["large", "xlarge", "2xlarge"]}. func (o NodePolicyOutput) InstanceSizes() LabelSelectorArgsPtrOutput { return o.ApplyT(func(v *NodePolicy) LabelSelectorArgsPtrOutput { return v.InstanceSizes }).(LabelSelectorArgsPtrOutput) @@ -362,6 +406,11 @@ func (o NodePolicyOutput) NodePoolName() pulumi.StringPtrOutput { return o.ApplyT(func(v *NodePolicy) pulumi.StringPtrOutput { return v.NodePoolName }).(pulumi.StringPtrOutput) } +// OCI-specific NodeClass configuration (VCN, subnets, images, block volumes, etc.). +func (o NodePolicyOutput) Oci() OCINodeClassSpecArgsPtrOutput { + return o.ApplyT(func(v *NodePolicy) OCINodeClassSpecArgsPtrOutput { return v.Oci }).(OCINodeClassSpecArgsPtrOutput) +} + // Operating systems for nodes. Example: {in: ["linux"]}. func (o NodePolicyOutput) OperatingSystems() LabelSelectorArgsPtrOutput { return o.ApplyT(func(v *NodePolicy) LabelSelectorArgsPtrOutput { return v.OperatingSystems }).(LabelSelectorArgsPtrOutput) @@ -376,6 +425,11 @@ func (o NodePolicyOutput) StartupTaints() TaintArgsArrayOutput { return o.ApplyT(func(v *NodePolicy) TaintArgsArrayOutput { return v.StartupTaints }).(TaintArgsArrayOutput) } +// UI tooltip text shown alongside startupTaints. +func (o NodePolicyOutput) StartupTaintsTip() pulumi.StringPtrOutput { + return o.ApplyT(func(v *NodePolicy) pulumi.StringPtrOutput { return v.StartupTaintsTip }).(pulumi.StringPtrOutput) +} + // Taints applied to provisioned nodes to control pod scheduling. Example: [{key: "dedicated", value: "gpu", effect: "NoSchedule"}]. func (o NodePolicyOutput) Taints() TaintArgsArrayOutput { return o.ApplyT(func(v *NodePolicy) TaintArgsArrayOutput { return v.Taints }).(TaintArgsArrayOutput) diff --git a/sdk/go/devzero/resources/pulumiTypes.go b/sdk/go/devzero/resources/pulumiTypes.go index 1e62fc5..eded373 100644 --- a/sdk/go/devzero/resources/pulumiTypes.go +++ b/sdk/go/devzero/resources/pulumiTypes.go @@ -2403,6 +2403,515 @@ func (o EmergencyResponseConfigArgsPtrOutput) OomMemoryMultiplier() pulumi.Float }).(pulumi.Float64PtrOutput) } +type GCPDiskArgs struct { + // Whether this disk is the boot disk. Example: true. + Boot *bool `pulumi:"boot"` + // GCP disk type. Example: 'pd-ssd'. + Category *string `pulumi:"category"` + // Secondary boot image used for container-image fast boot. Example: 'projects/my-project/global/images/my-cache-image'. + SecondaryBootImage *string `pulumi:"secondaryBootImage"` + // Secondary boot mode. Example: 'CONTAINER_IMAGE_CACHE'. + SecondaryBootMode *string `pulumi:"secondaryBootMode"` + // Disk size in GiB. Example: 100. + SizeGib *int `pulumi:"sizeGib"` +} + +// GCPDiskArgsInput is an input type that accepts GCPDiskArgsArgs and GCPDiskArgsOutput values. +// You can construct a concrete instance of `GCPDiskArgsInput` via: +// +// GCPDiskArgsArgs{...} +type GCPDiskArgsInput interface { + pulumi.Input + + ToGCPDiskArgsOutput() GCPDiskArgsOutput + ToGCPDiskArgsOutputWithContext(context.Context) GCPDiskArgsOutput +} + +type GCPDiskArgsArgs struct { + // Whether this disk is the boot disk. Example: true. + Boot pulumi.BoolPtrInput `pulumi:"boot"` + // GCP disk type. Example: 'pd-ssd'. + Category pulumi.StringPtrInput `pulumi:"category"` + // Secondary boot image used for container-image fast boot. Example: 'projects/my-project/global/images/my-cache-image'. + SecondaryBootImage pulumi.StringPtrInput `pulumi:"secondaryBootImage"` + // Secondary boot mode. Example: 'CONTAINER_IMAGE_CACHE'. + SecondaryBootMode pulumi.StringPtrInput `pulumi:"secondaryBootMode"` + // Disk size in GiB. Example: 100. + SizeGib pulumi.IntPtrInput `pulumi:"sizeGib"` +} + +func (GCPDiskArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GCPDiskArgs)(nil)).Elem() +} + +func (i GCPDiskArgsArgs) ToGCPDiskArgsOutput() GCPDiskArgsOutput { + return i.ToGCPDiskArgsOutputWithContext(context.Background()) +} + +func (i GCPDiskArgsArgs) ToGCPDiskArgsOutputWithContext(ctx context.Context) GCPDiskArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(GCPDiskArgsOutput) +} + +// GCPDiskArgsArrayInput is an input type that accepts GCPDiskArgsArray and GCPDiskArgsArrayOutput values. +// You can construct a concrete instance of `GCPDiskArgsArrayInput` via: +// +// GCPDiskArgsArray{ GCPDiskArgsArgs{...} } +type GCPDiskArgsArrayInput interface { + pulumi.Input + + ToGCPDiskArgsArrayOutput() GCPDiskArgsArrayOutput + ToGCPDiskArgsArrayOutputWithContext(context.Context) GCPDiskArgsArrayOutput +} + +type GCPDiskArgsArray []GCPDiskArgsInput + +func (GCPDiskArgsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GCPDiskArgs)(nil)).Elem() +} + +func (i GCPDiskArgsArray) ToGCPDiskArgsArrayOutput() GCPDiskArgsArrayOutput { + return i.ToGCPDiskArgsArrayOutputWithContext(context.Background()) +} + +func (i GCPDiskArgsArray) ToGCPDiskArgsArrayOutputWithContext(ctx context.Context) GCPDiskArgsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GCPDiskArgsArrayOutput) +} + +type GCPDiskArgsOutput struct{ *pulumi.OutputState } + +func (GCPDiskArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GCPDiskArgs)(nil)).Elem() +} + +func (o GCPDiskArgsOutput) ToGCPDiskArgsOutput() GCPDiskArgsOutput { + return o +} + +func (o GCPDiskArgsOutput) ToGCPDiskArgsOutputWithContext(ctx context.Context) GCPDiskArgsOutput { + return o +} + +// Whether this disk is the boot disk. Example: true. +func (o GCPDiskArgsOutput) Boot() pulumi.BoolPtrOutput { + return o.ApplyT(func(v GCPDiskArgs) *bool { return v.Boot }).(pulumi.BoolPtrOutput) +} + +// GCP disk type. Example: 'pd-ssd'. +func (o GCPDiskArgsOutput) Category() pulumi.StringPtrOutput { + return o.ApplyT(func(v GCPDiskArgs) *string { return v.Category }).(pulumi.StringPtrOutput) +} + +// Secondary boot image used for container-image fast boot. Example: 'projects/my-project/global/images/my-cache-image'. +func (o GCPDiskArgsOutput) SecondaryBootImage() pulumi.StringPtrOutput { + return o.ApplyT(func(v GCPDiskArgs) *string { return v.SecondaryBootImage }).(pulumi.StringPtrOutput) +} + +// Secondary boot mode. Example: 'CONTAINER_IMAGE_CACHE'. +func (o GCPDiskArgsOutput) SecondaryBootMode() pulumi.StringPtrOutput { + return o.ApplyT(func(v GCPDiskArgs) *string { return v.SecondaryBootMode }).(pulumi.StringPtrOutput) +} + +// Disk size in GiB. Example: 100. +func (o GCPDiskArgsOutput) SizeGib() pulumi.IntPtrOutput { + return o.ApplyT(func(v GCPDiskArgs) *int { return v.SizeGib }).(pulumi.IntPtrOutput) +} + +type GCPDiskArgsArrayOutput struct{ *pulumi.OutputState } + +func (GCPDiskArgsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GCPDiskArgs)(nil)).Elem() +} + +func (o GCPDiskArgsArrayOutput) ToGCPDiskArgsArrayOutput() GCPDiskArgsArrayOutput { + return o +} + +func (o GCPDiskArgsArrayOutput) ToGCPDiskArgsArrayOutputWithContext(ctx context.Context) GCPDiskArgsArrayOutput { + return o +} + +func (o GCPDiskArgsArrayOutput) Index(i pulumi.IntInput) GCPDiskArgsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GCPDiskArgs { + return vs[0].([]GCPDiskArgs)[vs[1].(int)] + }).(GCPDiskArgsOutput) +} + +type GCPImageSelectorTermArgs struct { + // Well-known alias for the GCP node image family. Example: 'cos@latest'. + Alias *string `pulumi:"alias"` + // Explicit GCP image ID. Example: 'projects/cos-cloud/global/images/cos-105-17412-156-59'. + Id *string `pulumi:"id"` +} + +// GCPImageSelectorTermArgsInput is an input type that accepts GCPImageSelectorTermArgsArgs and GCPImageSelectorTermArgsOutput values. +// You can construct a concrete instance of `GCPImageSelectorTermArgsInput` via: +// +// GCPImageSelectorTermArgsArgs{...} +type GCPImageSelectorTermArgsInput interface { + pulumi.Input + + ToGCPImageSelectorTermArgsOutput() GCPImageSelectorTermArgsOutput + ToGCPImageSelectorTermArgsOutputWithContext(context.Context) GCPImageSelectorTermArgsOutput +} + +type GCPImageSelectorTermArgsArgs struct { + // Well-known alias for the GCP node image family. Example: 'cos@latest'. + Alias pulumi.StringPtrInput `pulumi:"alias"` + // Explicit GCP image ID. Example: 'projects/cos-cloud/global/images/cos-105-17412-156-59'. + Id pulumi.StringPtrInput `pulumi:"id"` +} + +func (GCPImageSelectorTermArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GCPImageSelectorTermArgs)(nil)).Elem() +} + +func (i GCPImageSelectorTermArgsArgs) ToGCPImageSelectorTermArgsOutput() GCPImageSelectorTermArgsOutput { + return i.ToGCPImageSelectorTermArgsOutputWithContext(context.Background()) +} + +func (i GCPImageSelectorTermArgsArgs) ToGCPImageSelectorTermArgsOutputWithContext(ctx context.Context) GCPImageSelectorTermArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(GCPImageSelectorTermArgsOutput) +} + +// GCPImageSelectorTermArgsArrayInput is an input type that accepts GCPImageSelectorTermArgsArray and GCPImageSelectorTermArgsArrayOutput values. +// You can construct a concrete instance of `GCPImageSelectorTermArgsArrayInput` via: +// +// GCPImageSelectorTermArgsArray{ GCPImageSelectorTermArgsArgs{...} } +type GCPImageSelectorTermArgsArrayInput interface { + pulumi.Input + + ToGCPImageSelectorTermArgsArrayOutput() GCPImageSelectorTermArgsArrayOutput + ToGCPImageSelectorTermArgsArrayOutputWithContext(context.Context) GCPImageSelectorTermArgsArrayOutput +} + +type GCPImageSelectorTermArgsArray []GCPImageSelectorTermArgsInput + +func (GCPImageSelectorTermArgsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GCPImageSelectorTermArgs)(nil)).Elem() +} + +func (i GCPImageSelectorTermArgsArray) ToGCPImageSelectorTermArgsArrayOutput() GCPImageSelectorTermArgsArrayOutput { + return i.ToGCPImageSelectorTermArgsArrayOutputWithContext(context.Background()) +} + +func (i GCPImageSelectorTermArgsArray) ToGCPImageSelectorTermArgsArrayOutputWithContext(ctx context.Context) GCPImageSelectorTermArgsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GCPImageSelectorTermArgsArrayOutput) +} + +type GCPImageSelectorTermArgsOutput struct{ *pulumi.OutputState } + +func (GCPImageSelectorTermArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GCPImageSelectorTermArgs)(nil)).Elem() +} + +func (o GCPImageSelectorTermArgsOutput) ToGCPImageSelectorTermArgsOutput() GCPImageSelectorTermArgsOutput { + return o +} + +func (o GCPImageSelectorTermArgsOutput) ToGCPImageSelectorTermArgsOutputWithContext(ctx context.Context) GCPImageSelectorTermArgsOutput { + return o +} + +// Well-known alias for the GCP node image family. Example: 'cos@latest'. +func (o GCPImageSelectorTermArgsOutput) Alias() pulumi.StringPtrOutput { + return o.ApplyT(func(v GCPImageSelectorTermArgs) *string { return v.Alias }).(pulumi.StringPtrOutput) +} + +// Explicit GCP image ID. Example: 'projects/cos-cloud/global/images/cos-105-17412-156-59'. +func (o GCPImageSelectorTermArgsOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v GCPImageSelectorTermArgs) *string { return v.Id }).(pulumi.StringPtrOutput) +} + +type GCPImageSelectorTermArgsArrayOutput struct{ *pulumi.OutputState } + +func (GCPImageSelectorTermArgsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GCPImageSelectorTermArgs)(nil)).Elem() +} + +func (o GCPImageSelectorTermArgsArrayOutput) ToGCPImageSelectorTermArgsArrayOutput() GCPImageSelectorTermArgsArrayOutput { + return o +} + +func (o GCPImageSelectorTermArgsArrayOutput) ToGCPImageSelectorTermArgsArrayOutputWithContext(ctx context.Context) GCPImageSelectorTermArgsArrayOutput { + return o +} + +func (o GCPImageSelectorTermArgsArrayOutput) Index(i pulumi.IntInput) GCPImageSelectorTermArgsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GCPImageSelectorTermArgs { + return vs[0].([]GCPImageSelectorTermArgs)[vs[1].(int)] + }).(GCPImageSelectorTermArgsOutput) +} + +type GCPNodeClassSpecArgs struct { + // Disks attached to provisioned nodes. Example: [{sizeGib: 100, category: "pd-ssd", boot: true}]. + Disks []GCPDiskArgs `pulumi:"disks"` + // GCP node image family shorthand used when no imageSelectorTerms are specified. Example: 'cos'. + ImageFamily *string `pulumi:"imageFamily"` + // Selectors for the node images used to launch nodes. Example: [{alias: "cos@latest"}]. + ImageSelectorTerms []GCPImageSelectorTermArgs `pulumi:"imageSelectorTerms"` + // Kubelet configuration overrides applied to all nodes in this class. + Kubelet *KubeletConfigurationArgs `pulumi:"kubelet"` + // GCP labels applied to all resources created by this node class. Example: {"environment": "production"}. + Labels map[string]string `pulumi:"labels"` + // GCE instance metadata applied to provisioned nodes. Example: {"disable-legacy-endpoints": "true"}. + Metadata map[string]string `pulumi:"metadata"` + // GCP network tags applied to provisioned nodes for firewall targeting. Example: ["karpenter-node"]. + NetworkTags []string `pulumi:"networkTags"` + // GCP service account email attached to provisioned nodes. Example: 'karpenter@my-project.iam.gserviceaccount.com'. + ServiceAccount *string `pulumi:"serviceAccount"` +} + +// GCPNodeClassSpecArgsInput is an input type that accepts GCPNodeClassSpecArgsArgs and GCPNodeClassSpecArgsOutput values. +// You can construct a concrete instance of `GCPNodeClassSpecArgsInput` via: +// +// GCPNodeClassSpecArgsArgs{...} +type GCPNodeClassSpecArgsInput interface { + pulumi.Input + + ToGCPNodeClassSpecArgsOutput() GCPNodeClassSpecArgsOutput + ToGCPNodeClassSpecArgsOutputWithContext(context.Context) GCPNodeClassSpecArgsOutput +} + +type GCPNodeClassSpecArgsArgs struct { + // Disks attached to provisioned nodes. Example: [{sizeGib: 100, category: "pd-ssd", boot: true}]. + Disks GCPDiskArgsArrayInput `pulumi:"disks"` + // GCP node image family shorthand used when no imageSelectorTerms are specified. Example: 'cos'. + ImageFamily pulumi.StringPtrInput `pulumi:"imageFamily"` + // Selectors for the node images used to launch nodes. Example: [{alias: "cos@latest"}]. + ImageSelectorTerms GCPImageSelectorTermArgsArrayInput `pulumi:"imageSelectorTerms"` + // Kubelet configuration overrides applied to all nodes in this class. + Kubelet KubeletConfigurationArgsPtrInput `pulumi:"kubelet"` + // GCP labels applied to all resources created by this node class. Example: {"environment": "production"}. + Labels pulumi.StringMapInput `pulumi:"labels"` + // GCE instance metadata applied to provisioned nodes. Example: {"disable-legacy-endpoints": "true"}. + Metadata pulumi.StringMapInput `pulumi:"metadata"` + // GCP network tags applied to provisioned nodes for firewall targeting. Example: ["karpenter-node"]. + NetworkTags pulumi.StringArrayInput `pulumi:"networkTags"` + // GCP service account email attached to provisioned nodes. Example: 'karpenter@my-project.iam.gserviceaccount.com'. + ServiceAccount pulumi.StringPtrInput `pulumi:"serviceAccount"` +} + +func (GCPNodeClassSpecArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GCPNodeClassSpecArgs)(nil)).Elem() +} + +func (i GCPNodeClassSpecArgsArgs) ToGCPNodeClassSpecArgsOutput() GCPNodeClassSpecArgsOutput { + return i.ToGCPNodeClassSpecArgsOutputWithContext(context.Background()) +} + +func (i GCPNodeClassSpecArgsArgs) ToGCPNodeClassSpecArgsOutputWithContext(ctx context.Context) GCPNodeClassSpecArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(GCPNodeClassSpecArgsOutput) +} + +func (i GCPNodeClassSpecArgsArgs) ToGCPNodeClassSpecArgsPtrOutput() GCPNodeClassSpecArgsPtrOutput { + return i.ToGCPNodeClassSpecArgsPtrOutputWithContext(context.Background()) +} + +func (i GCPNodeClassSpecArgsArgs) ToGCPNodeClassSpecArgsPtrOutputWithContext(ctx context.Context) GCPNodeClassSpecArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GCPNodeClassSpecArgsOutput).ToGCPNodeClassSpecArgsPtrOutputWithContext(ctx) +} + +// GCPNodeClassSpecArgsPtrInput is an input type that accepts GCPNodeClassSpecArgsArgs, GCPNodeClassSpecArgsPtr and GCPNodeClassSpecArgsPtrOutput values. +// You can construct a concrete instance of `GCPNodeClassSpecArgsPtrInput` via: +// +// GCPNodeClassSpecArgsArgs{...} +// +// or: +// +// nil +type GCPNodeClassSpecArgsPtrInput interface { + pulumi.Input + + ToGCPNodeClassSpecArgsPtrOutput() GCPNodeClassSpecArgsPtrOutput + ToGCPNodeClassSpecArgsPtrOutputWithContext(context.Context) GCPNodeClassSpecArgsPtrOutput +} + +type gcpnodeClassSpecArgsPtrType GCPNodeClassSpecArgsArgs + +func GCPNodeClassSpecArgsPtr(v *GCPNodeClassSpecArgsArgs) GCPNodeClassSpecArgsPtrInput { + return (*gcpnodeClassSpecArgsPtrType)(v) +} + +func (*gcpnodeClassSpecArgsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**GCPNodeClassSpecArgs)(nil)).Elem() +} + +func (i *gcpnodeClassSpecArgsPtrType) ToGCPNodeClassSpecArgsPtrOutput() GCPNodeClassSpecArgsPtrOutput { + return i.ToGCPNodeClassSpecArgsPtrOutputWithContext(context.Background()) +} + +func (i *gcpnodeClassSpecArgsPtrType) ToGCPNodeClassSpecArgsPtrOutputWithContext(ctx context.Context) GCPNodeClassSpecArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GCPNodeClassSpecArgsPtrOutput) +} + +type GCPNodeClassSpecArgsOutput struct{ *pulumi.OutputState } + +func (GCPNodeClassSpecArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GCPNodeClassSpecArgs)(nil)).Elem() +} + +func (o GCPNodeClassSpecArgsOutput) ToGCPNodeClassSpecArgsOutput() GCPNodeClassSpecArgsOutput { + return o +} + +func (o GCPNodeClassSpecArgsOutput) ToGCPNodeClassSpecArgsOutputWithContext(ctx context.Context) GCPNodeClassSpecArgsOutput { + return o +} + +func (o GCPNodeClassSpecArgsOutput) ToGCPNodeClassSpecArgsPtrOutput() GCPNodeClassSpecArgsPtrOutput { + return o.ToGCPNodeClassSpecArgsPtrOutputWithContext(context.Background()) +} + +func (o GCPNodeClassSpecArgsOutput) ToGCPNodeClassSpecArgsPtrOutputWithContext(ctx context.Context) GCPNodeClassSpecArgsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v GCPNodeClassSpecArgs) *GCPNodeClassSpecArgs { + return &v + }).(GCPNodeClassSpecArgsPtrOutput) +} + +// Disks attached to provisioned nodes. Example: [{sizeGib: 100, category: "pd-ssd", boot: true}]. +func (o GCPNodeClassSpecArgsOutput) Disks() GCPDiskArgsArrayOutput { + return o.ApplyT(func(v GCPNodeClassSpecArgs) []GCPDiskArgs { return v.Disks }).(GCPDiskArgsArrayOutput) +} + +// GCP node image family shorthand used when no imageSelectorTerms are specified. Example: 'cos'. +func (o GCPNodeClassSpecArgsOutput) ImageFamily() pulumi.StringPtrOutput { + return o.ApplyT(func(v GCPNodeClassSpecArgs) *string { return v.ImageFamily }).(pulumi.StringPtrOutput) +} + +// Selectors for the node images used to launch nodes. Example: [{alias: "cos@latest"}]. +func (o GCPNodeClassSpecArgsOutput) ImageSelectorTerms() GCPImageSelectorTermArgsArrayOutput { + return o.ApplyT(func(v GCPNodeClassSpecArgs) []GCPImageSelectorTermArgs { return v.ImageSelectorTerms }).(GCPImageSelectorTermArgsArrayOutput) +} + +// Kubelet configuration overrides applied to all nodes in this class. +func (o GCPNodeClassSpecArgsOutput) Kubelet() KubeletConfigurationArgsPtrOutput { + return o.ApplyT(func(v GCPNodeClassSpecArgs) *KubeletConfigurationArgs { return v.Kubelet }).(KubeletConfigurationArgsPtrOutput) +} + +// GCP labels applied to all resources created by this node class. Example: {"environment": "production"}. +func (o GCPNodeClassSpecArgsOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v GCPNodeClassSpecArgs) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +// GCE instance metadata applied to provisioned nodes. Example: {"disable-legacy-endpoints": "true"}. +func (o GCPNodeClassSpecArgsOutput) Metadata() pulumi.StringMapOutput { + return o.ApplyT(func(v GCPNodeClassSpecArgs) map[string]string { return v.Metadata }).(pulumi.StringMapOutput) +} + +// GCP network tags applied to provisioned nodes for firewall targeting. Example: ["karpenter-node"]. +func (o GCPNodeClassSpecArgsOutput) NetworkTags() pulumi.StringArrayOutput { + return o.ApplyT(func(v GCPNodeClassSpecArgs) []string { return v.NetworkTags }).(pulumi.StringArrayOutput) +} + +// GCP service account email attached to provisioned nodes. Example: 'karpenter@my-project.iam.gserviceaccount.com'. +func (o GCPNodeClassSpecArgsOutput) ServiceAccount() pulumi.StringPtrOutput { + return o.ApplyT(func(v GCPNodeClassSpecArgs) *string { return v.ServiceAccount }).(pulumi.StringPtrOutput) +} + +type GCPNodeClassSpecArgsPtrOutput struct{ *pulumi.OutputState } + +func (GCPNodeClassSpecArgsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**GCPNodeClassSpecArgs)(nil)).Elem() +} + +func (o GCPNodeClassSpecArgsPtrOutput) ToGCPNodeClassSpecArgsPtrOutput() GCPNodeClassSpecArgsPtrOutput { + return o +} + +func (o GCPNodeClassSpecArgsPtrOutput) ToGCPNodeClassSpecArgsPtrOutputWithContext(ctx context.Context) GCPNodeClassSpecArgsPtrOutput { + return o +} + +func (o GCPNodeClassSpecArgsPtrOutput) Elem() GCPNodeClassSpecArgsOutput { + return o.ApplyT(func(v *GCPNodeClassSpecArgs) GCPNodeClassSpecArgs { + if v != nil { + return *v + } + var ret GCPNodeClassSpecArgs + return ret + }).(GCPNodeClassSpecArgsOutput) +} + +// Disks attached to provisioned nodes. Example: [{sizeGib: 100, category: "pd-ssd", boot: true}]. +func (o GCPNodeClassSpecArgsPtrOutput) Disks() GCPDiskArgsArrayOutput { + return o.ApplyT(func(v *GCPNodeClassSpecArgs) []GCPDiskArgs { + if v == nil { + return nil + } + return v.Disks + }).(GCPDiskArgsArrayOutput) +} + +// GCP node image family shorthand used when no imageSelectorTerms are specified. Example: 'cos'. +func (o GCPNodeClassSpecArgsPtrOutput) ImageFamily() pulumi.StringPtrOutput { + return o.ApplyT(func(v *GCPNodeClassSpecArgs) *string { + if v == nil { + return nil + } + return v.ImageFamily + }).(pulumi.StringPtrOutput) +} + +// Selectors for the node images used to launch nodes. Example: [{alias: "cos@latest"}]. +func (o GCPNodeClassSpecArgsPtrOutput) ImageSelectorTerms() GCPImageSelectorTermArgsArrayOutput { + return o.ApplyT(func(v *GCPNodeClassSpecArgs) []GCPImageSelectorTermArgs { + if v == nil { + return nil + } + return v.ImageSelectorTerms + }).(GCPImageSelectorTermArgsArrayOutput) +} + +// Kubelet configuration overrides applied to all nodes in this class. +func (o GCPNodeClassSpecArgsPtrOutput) Kubelet() KubeletConfigurationArgsPtrOutput { + return o.ApplyT(func(v *GCPNodeClassSpecArgs) *KubeletConfigurationArgs { + if v == nil { + return nil + } + return v.Kubelet + }).(KubeletConfigurationArgsPtrOutput) +} + +// GCP labels applied to all resources created by this node class. Example: {"environment": "production"}. +func (o GCPNodeClassSpecArgsPtrOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v *GCPNodeClassSpecArgs) map[string]string { + if v == nil { + return nil + } + return v.Labels + }).(pulumi.StringMapOutput) +} + +// GCE instance metadata applied to provisioned nodes. Example: {"disable-legacy-endpoints": "true"}. +func (o GCPNodeClassSpecArgsPtrOutput) Metadata() pulumi.StringMapOutput { + return o.ApplyT(func(v *GCPNodeClassSpecArgs) map[string]string { + if v == nil { + return nil + } + return v.Metadata + }).(pulumi.StringMapOutput) +} + +// GCP network tags applied to provisioned nodes for firewall targeting. Example: ["karpenter-node"]. +func (o GCPNodeClassSpecArgsPtrOutput) NetworkTags() pulumi.StringArrayOutput { + return o.ApplyT(func(v *GCPNodeClassSpecArgs) []string { + if v == nil { + return nil + } + return v.NetworkTags + }).(pulumi.StringArrayOutput) +} + +// GCP service account email attached to provisioned nodes. Example: 'karpenter@my-project.iam.gserviceaccount.com'. +func (o GCPNodeClassSpecArgsPtrOutput) ServiceAccount() pulumi.StringPtrOutput { + return o.ApplyT(func(v *GCPNodeClassSpecArgs) *string { + if v == nil { + return nil + } + return v.ServiceAccount + }).(pulumi.StringPtrOutput) +} + type HPABehaviorArgs struct { // Scale-down behavior rules. ScaleDown *HPAScalingRulesArgs `pulumi:"scaleDown"` @@ -3781,971 +4290,3345 @@ func (o HorizontalScalingArgsPtrOutput) TargetUtilization() pulumi.Float64PtrOut }).(pulumi.Float64PtrOutput) } -type KubeletConfigurationArgs struct { - // DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. - ClusterDns []string `pulumi:"clusterDns"` - // Whether to enforce CPU CFS quota limits for containers. Example: true. - CpuCfsQuota *bool `pulumi:"cpuCfsQuota"` - // Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. - EvictionHard map[string]string `pulumi:"evictionHard"` - // Maximum pod termination grace period (seconds) during eviction. Example: 90. - EvictionMaxPodGracePeriod *int `pulumi:"evictionMaxPodGracePeriod"` - // Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. - EvictionSoft map[string]string `pulumi:"evictionSoft"` - // Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. - EvictionSoftGracePeriod map[string]string `pulumi:"evictionSoftGracePeriod"` - // Disk usage % that triggers image garbage collection. Example: 85. - ImageGcHighThresholdPercent *int `pulumi:"imageGcHighThresholdPercent"` - // Disk usage % at which image GC stops freeing space. Example: 70. - ImageGcLowThresholdPercent *int `pulumi:"imageGcLowThresholdPercent"` - // Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. - KubeReserved map[string]string `pulumi:"kubeReserved"` - // Maximum number of pods allowed per node. Example: 110. - MaxPods *int `pulumi:"maxPods"` - // Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. - PodsPerCore *int `pulumi:"podsPerCore"` - // Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. - SystemReserved map[string]string `pulumi:"systemReserved"` +type JvmHeapRuleConfigArgs struct { + // Enable JVM heap sizing overrides. Example: true. + Enabled *bool `pulumi:"enabled"` + // Multiplier applied above the target usage to derive the heap size. Example: 1.3. + HeadroomMultiplier *float64 `pulumi:"headroomMultiplier"` + // Maximum JVM heap size in bytes. Example: 2147483648. + MaxHeapBytes *int `pulumi:"maxHeapBytes"` + // Minimum JVM heap size in bytes. Example: 134217728. + MinHeapBytes *int `pulumi:"minHeapBytes"` + // Non-heap memory overhead in bytes. Takes precedence over nonHeapOverheadPercent when set. Example: 268435456. + NonHeapOverheadBytes *int `pulumi:"nonHeapOverheadBytes"` + // Non-heap memory overhead as a percentage of container memory (0-1). Example: 0.2. + NonHeapOverheadPercent *float64 `pulumi:"nonHeapOverheadPercent"` + // Prefer the JVM's native container-aware heap sizing (-XX:+UseContainerSupport) over explicit -Xmx/-Xms flags. Example: false. + PreferContainerSupport *bool `pulumi:"preferContainerSupport"` + // Percentile of usage data used as the heap sizing target (0-1). Example: 0.95. + TargetPercentile *float64 `pulumi:"targetPercentile"` } -// KubeletConfigurationArgsInput is an input type that accepts KubeletConfigurationArgsArgs and KubeletConfigurationArgsOutput values. -// You can construct a concrete instance of `KubeletConfigurationArgsInput` via: +// JvmHeapRuleConfigArgsInput is an input type that accepts JvmHeapRuleConfigArgsArgs and JvmHeapRuleConfigArgsOutput values. +// You can construct a concrete instance of `JvmHeapRuleConfigArgsInput` via: // -// KubeletConfigurationArgsArgs{...} -type KubeletConfigurationArgsInput interface { +// JvmHeapRuleConfigArgsArgs{...} +type JvmHeapRuleConfigArgsInput interface { pulumi.Input - ToKubeletConfigurationArgsOutput() KubeletConfigurationArgsOutput - ToKubeletConfigurationArgsOutputWithContext(context.Context) KubeletConfigurationArgsOutput + ToJvmHeapRuleConfigArgsOutput() JvmHeapRuleConfigArgsOutput + ToJvmHeapRuleConfigArgsOutputWithContext(context.Context) JvmHeapRuleConfigArgsOutput } -type KubeletConfigurationArgsArgs struct { - // DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. - ClusterDns pulumi.StringArrayInput `pulumi:"clusterDns"` - // Whether to enforce CPU CFS quota limits for containers. Example: true. - CpuCfsQuota pulumi.BoolPtrInput `pulumi:"cpuCfsQuota"` - // Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. - EvictionHard pulumi.StringMapInput `pulumi:"evictionHard"` - // Maximum pod termination grace period (seconds) during eviction. Example: 90. - EvictionMaxPodGracePeriod pulumi.IntPtrInput `pulumi:"evictionMaxPodGracePeriod"` - // Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. - EvictionSoft pulumi.StringMapInput `pulumi:"evictionSoft"` - // Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. - EvictionSoftGracePeriod pulumi.StringMapInput `pulumi:"evictionSoftGracePeriod"` - // Disk usage % that triggers image garbage collection. Example: 85. - ImageGcHighThresholdPercent pulumi.IntPtrInput `pulumi:"imageGcHighThresholdPercent"` - // Disk usage % at which image GC stops freeing space. Example: 70. - ImageGcLowThresholdPercent pulumi.IntPtrInput `pulumi:"imageGcLowThresholdPercent"` - // Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. - KubeReserved pulumi.StringMapInput `pulumi:"kubeReserved"` - // Maximum number of pods allowed per node. Example: 110. - MaxPods pulumi.IntPtrInput `pulumi:"maxPods"` - // Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. - PodsPerCore pulumi.IntPtrInput `pulumi:"podsPerCore"` - // Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. - SystemReserved pulumi.StringMapInput `pulumi:"systemReserved"` +type JvmHeapRuleConfigArgsArgs struct { + // Enable JVM heap sizing overrides. Example: true. + Enabled pulumi.BoolPtrInput `pulumi:"enabled"` + // Multiplier applied above the target usage to derive the heap size. Example: 1.3. + HeadroomMultiplier pulumi.Float64PtrInput `pulumi:"headroomMultiplier"` + // Maximum JVM heap size in bytes. Example: 2147483648. + MaxHeapBytes pulumi.IntPtrInput `pulumi:"maxHeapBytes"` + // Minimum JVM heap size in bytes. Example: 134217728. + MinHeapBytes pulumi.IntPtrInput `pulumi:"minHeapBytes"` + // Non-heap memory overhead in bytes. Takes precedence over nonHeapOverheadPercent when set. Example: 268435456. + NonHeapOverheadBytes pulumi.IntPtrInput `pulumi:"nonHeapOverheadBytes"` + // Non-heap memory overhead as a percentage of container memory (0-1). Example: 0.2. + NonHeapOverheadPercent pulumi.Float64PtrInput `pulumi:"nonHeapOverheadPercent"` + // Prefer the JVM's native container-aware heap sizing (-XX:+UseContainerSupport) over explicit -Xmx/-Xms flags. Example: false. + PreferContainerSupport pulumi.BoolPtrInput `pulumi:"preferContainerSupport"` + // Percentile of usage data used as the heap sizing target (0-1). Example: 0.95. + TargetPercentile pulumi.Float64PtrInput `pulumi:"targetPercentile"` } -func (KubeletConfigurationArgsArgs) ElementType() reflect.Type { - return reflect.TypeOf((*KubeletConfigurationArgs)(nil)).Elem() +func (JvmHeapRuleConfigArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*JvmHeapRuleConfigArgs)(nil)).Elem() } -func (i KubeletConfigurationArgsArgs) ToKubeletConfigurationArgsOutput() KubeletConfigurationArgsOutput { - return i.ToKubeletConfigurationArgsOutputWithContext(context.Background()) +func (i JvmHeapRuleConfigArgsArgs) ToJvmHeapRuleConfigArgsOutput() JvmHeapRuleConfigArgsOutput { + return i.ToJvmHeapRuleConfigArgsOutputWithContext(context.Background()) } -func (i KubeletConfigurationArgsArgs) ToKubeletConfigurationArgsOutputWithContext(ctx context.Context) KubeletConfigurationArgsOutput { - return pulumi.ToOutputWithContext(ctx, i).(KubeletConfigurationArgsOutput) +func (i JvmHeapRuleConfigArgsArgs) ToJvmHeapRuleConfigArgsOutputWithContext(ctx context.Context) JvmHeapRuleConfigArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(JvmHeapRuleConfigArgsOutput) } -func (i KubeletConfigurationArgsArgs) ToKubeletConfigurationArgsPtrOutput() KubeletConfigurationArgsPtrOutput { - return i.ToKubeletConfigurationArgsPtrOutputWithContext(context.Background()) +func (i JvmHeapRuleConfigArgsArgs) ToJvmHeapRuleConfigArgsPtrOutput() JvmHeapRuleConfigArgsPtrOutput { + return i.ToJvmHeapRuleConfigArgsPtrOutputWithContext(context.Background()) } -func (i KubeletConfigurationArgsArgs) ToKubeletConfigurationArgsPtrOutputWithContext(ctx context.Context) KubeletConfigurationArgsPtrOutput { - return pulumi.ToOutputWithContext(ctx, i).(KubeletConfigurationArgsOutput).ToKubeletConfigurationArgsPtrOutputWithContext(ctx) +func (i JvmHeapRuleConfigArgsArgs) ToJvmHeapRuleConfigArgsPtrOutputWithContext(ctx context.Context) JvmHeapRuleConfigArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(JvmHeapRuleConfigArgsOutput).ToJvmHeapRuleConfigArgsPtrOutputWithContext(ctx) } -// KubeletConfigurationArgsPtrInput is an input type that accepts KubeletConfigurationArgsArgs, KubeletConfigurationArgsPtr and KubeletConfigurationArgsPtrOutput values. -// You can construct a concrete instance of `KubeletConfigurationArgsPtrInput` via: +// JvmHeapRuleConfigArgsPtrInput is an input type that accepts JvmHeapRuleConfigArgsArgs, JvmHeapRuleConfigArgsPtr and JvmHeapRuleConfigArgsPtrOutput values. +// You can construct a concrete instance of `JvmHeapRuleConfigArgsPtrInput` via: // -// KubeletConfigurationArgsArgs{...} +// JvmHeapRuleConfigArgsArgs{...} // // or: // // nil -type KubeletConfigurationArgsPtrInput interface { +type JvmHeapRuleConfigArgsPtrInput interface { pulumi.Input - ToKubeletConfigurationArgsPtrOutput() KubeletConfigurationArgsPtrOutput - ToKubeletConfigurationArgsPtrOutputWithContext(context.Context) KubeletConfigurationArgsPtrOutput + ToJvmHeapRuleConfigArgsPtrOutput() JvmHeapRuleConfigArgsPtrOutput + ToJvmHeapRuleConfigArgsPtrOutputWithContext(context.Context) JvmHeapRuleConfigArgsPtrOutput } -type kubeletConfigurationArgsPtrType KubeletConfigurationArgsArgs +type jvmHeapRuleConfigArgsPtrType JvmHeapRuleConfigArgsArgs -func KubeletConfigurationArgsPtr(v *KubeletConfigurationArgsArgs) KubeletConfigurationArgsPtrInput { - return (*kubeletConfigurationArgsPtrType)(v) +func JvmHeapRuleConfigArgsPtr(v *JvmHeapRuleConfigArgsArgs) JvmHeapRuleConfigArgsPtrInput { + return (*jvmHeapRuleConfigArgsPtrType)(v) } -func (*kubeletConfigurationArgsPtrType) ElementType() reflect.Type { - return reflect.TypeOf((**KubeletConfigurationArgs)(nil)).Elem() +func (*jvmHeapRuleConfigArgsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**JvmHeapRuleConfigArgs)(nil)).Elem() } -func (i *kubeletConfigurationArgsPtrType) ToKubeletConfigurationArgsPtrOutput() KubeletConfigurationArgsPtrOutput { - return i.ToKubeletConfigurationArgsPtrOutputWithContext(context.Background()) +func (i *jvmHeapRuleConfigArgsPtrType) ToJvmHeapRuleConfigArgsPtrOutput() JvmHeapRuleConfigArgsPtrOutput { + return i.ToJvmHeapRuleConfigArgsPtrOutputWithContext(context.Background()) } -func (i *kubeletConfigurationArgsPtrType) ToKubeletConfigurationArgsPtrOutputWithContext(ctx context.Context) KubeletConfigurationArgsPtrOutput { - return pulumi.ToOutputWithContext(ctx, i).(KubeletConfigurationArgsPtrOutput) +func (i *jvmHeapRuleConfigArgsPtrType) ToJvmHeapRuleConfigArgsPtrOutputWithContext(ctx context.Context) JvmHeapRuleConfigArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(JvmHeapRuleConfigArgsPtrOutput) } -type KubeletConfigurationArgsOutput struct{ *pulumi.OutputState } +type JvmHeapRuleConfigArgsOutput struct{ *pulumi.OutputState } -func (KubeletConfigurationArgsOutput) ElementType() reflect.Type { - return reflect.TypeOf((*KubeletConfigurationArgs)(nil)).Elem() +func (JvmHeapRuleConfigArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*JvmHeapRuleConfigArgs)(nil)).Elem() } -func (o KubeletConfigurationArgsOutput) ToKubeletConfigurationArgsOutput() KubeletConfigurationArgsOutput { +func (o JvmHeapRuleConfigArgsOutput) ToJvmHeapRuleConfigArgsOutput() JvmHeapRuleConfigArgsOutput { return o } -func (o KubeletConfigurationArgsOutput) ToKubeletConfigurationArgsOutputWithContext(ctx context.Context) KubeletConfigurationArgsOutput { +func (o JvmHeapRuleConfigArgsOutput) ToJvmHeapRuleConfigArgsOutputWithContext(ctx context.Context) JvmHeapRuleConfigArgsOutput { return o } -func (o KubeletConfigurationArgsOutput) ToKubeletConfigurationArgsPtrOutput() KubeletConfigurationArgsPtrOutput { - return o.ToKubeletConfigurationArgsPtrOutputWithContext(context.Background()) +func (o JvmHeapRuleConfigArgsOutput) ToJvmHeapRuleConfigArgsPtrOutput() JvmHeapRuleConfigArgsPtrOutput { + return o.ToJvmHeapRuleConfigArgsPtrOutputWithContext(context.Background()) } -func (o KubeletConfigurationArgsOutput) ToKubeletConfigurationArgsPtrOutputWithContext(ctx context.Context) KubeletConfigurationArgsPtrOutput { - return o.ApplyTWithContext(ctx, func(_ context.Context, v KubeletConfigurationArgs) *KubeletConfigurationArgs { +func (o JvmHeapRuleConfigArgsOutput) ToJvmHeapRuleConfigArgsPtrOutputWithContext(ctx context.Context) JvmHeapRuleConfigArgsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v JvmHeapRuleConfigArgs) *JvmHeapRuleConfigArgs { return &v - }).(KubeletConfigurationArgsPtrOutput) -} - -// DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. -func (o KubeletConfigurationArgsOutput) ClusterDns() pulumi.StringArrayOutput { - return o.ApplyT(func(v KubeletConfigurationArgs) []string { return v.ClusterDns }).(pulumi.StringArrayOutput) -} - -// Whether to enforce CPU CFS quota limits for containers. Example: true. -func (o KubeletConfigurationArgsOutput) CpuCfsQuota() pulumi.BoolPtrOutput { - return o.ApplyT(func(v KubeletConfigurationArgs) *bool { return v.CpuCfsQuota }).(pulumi.BoolPtrOutput) -} - -// Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. -func (o KubeletConfigurationArgsOutput) EvictionHard() pulumi.StringMapOutput { - return o.ApplyT(func(v KubeletConfigurationArgs) map[string]string { return v.EvictionHard }).(pulumi.StringMapOutput) -} - -// Maximum pod termination grace period (seconds) during eviction. Example: 90. -func (o KubeletConfigurationArgsOutput) EvictionMaxPodGracePeriod() pulumi.IntPtrOutput { - return o.ApplyT(func(v KubeletConfigurationArgs) *int { return v.EvictionMaxPodGracePeriod }).(pulumi.IntPtrOutput) + }).(JvmHeapRuleConfigArgsPtrOutput) } -// Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. -func (o KubeletConfigurationArgsOutput) EvictionSoft() pulumi.StringMapOutput { - return o.ApplyT(func(v KubeletConfigurationArgs) map[string]string { return v.EvictionSoft }).(pulumi.StringMapOutput) +// Enable JVM heap sizing overrides. Example: true. +func (o JvmHeapRuleConfigArgsOutput) Enabled() pulumi.BoolPtrOutput { + return o.ApplyT(func(v JvmHeapRuleConfigArgs) *bool { return v.Enabled }).(pulumi.BoolPtrOutput) } -// Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. -func (o KubeletConfigurationArgsOutput) EvictionSoftGracePeriod() pulumi.StringMapOutput { - return o.ApplyT(func(v KubeletConfigurationArgs) map[string]string { return v.EvictionSoftGracePeriod }).(pulumi.StringMapOutput) +// Multiplier applied above the target usage to derive the heap size. Example: 1.3. +func (o JvmHeapRuleConfigArgsOutput) HeadroomMultiplier() pulumi.Float64PtrOutput { + return o.ApplyT(func(v JvmHeapRuleConfigArgs) *float64 { return v.HeadroomMultiplier }).(pulumi.Float64PtrOutput) } -// Disk usage % that triggers image garbage collection. Example: 85. -func (o KubeletConfigurationArgsOutput) ImageGcHighThresholdPercent() pulumi.IntPtrOutput { - return o.ApplyT(func(v KubeletConfigurationArgs) *int { return v.ImageGcHighThresholdPercent }).(pulumi.IntPtrOutput) +// Maximum JVM heap size in bytes. Example: 2147483648. +func (o JvmHeapRuleConfigArgsOutput) MaxHeapBytes() pulumi.IntPtrOutput { + return o.ApplyT(func(v JvmHeapRuleConfigArgs) *int { return v.MaxHeapBytes }).(pulumi.IntPtrOutput) } -// Disk usage % at which image GC stops freeing space. Example: 70. -func (o KubeletConfigurationArgsOutput) ImageGcLowThresholdPercent() pulumi.IntPtrOutput { - return o.ApplyT(func(v KubeletConfigurationArgs) *int { return v.ImageGcLowThresholdPercent }).(pulumi.IntPtrOutput) +// Minimum JVM heap size in bytes. Example: 134217728. +func (o JvmHeapRuleConfigArgsOutput) MinHeapBytes() pulumi.IntPtrOutput { + return o.ApplyT(func(v JvmHeapRuleConfigArgs) *int { return v.MinHeapBytes }).(pulumi.IntPtrOutput) } -// Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. -func (o KubeletConfigurationArgsOutput) KubeReserved() pulumi.StringMapOutput { - return o.ApplyT(func(v KubeletConfigurationArgs) map[string]string { return v.KubeReserved }).(pulumi.StringMapOutput) +// Non-heap memory overhead in bytes. Takes precedence over nonHeapOverheadPercent when set. Example: 268435456. +func (o JvmHeapRuleConfigArgsOutput) NonHeapOverheadBytes() pulumi.IntPtrOutput { + return o.ApplyT(func(v JvmHeapRuleConfigArgs) *int { return v.NonHeapOverheadBytes }).(pulumi.IntPtrOutput) } -// Maximum number of pods allowed per node. Example: 110. -func (o KubeletConfigurationArgsOutput) MaxPods() pulumi.IntPtrOutput { - return o.ApplyT(func(v KubeletConfigurationArgs) *int { return v.MaxPods }).(pulumi.IntPtrOutput) +// Non-heap memory overhead as a percentage of container memory (0-1). Example: 0.2. +func (o JvmHeapRuleConfigArgsOutput) NonHeapOverheadPercent() pulumi.Float64PtrOutput { + return o.ApplyT(func(v JvmHeapRuleConfigArgs) *float64 { return v.NonHeapOverheadPercent }).(pulumi.Float64PtrOutput) } -// Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. -func (o KubeletConfigurationArgsOutput) PodsPerCore() pulumi.IntPtrOutput { - return o.ApplyT(func(v KubeletConfigurationArgs) *int { return v.PodsPerCore }).(pulumi.IntPtrOutput) +// Prefer the JVM's native container-aware heap sizing (-XX:+UseContainerSupport) over explicit -Xmx/-Xms flags. Example: false. +func (o JvmHeapRuleConfigArgsOutput) PreferContainerSupport() pulumi.BoolPtrOutput { + return o.ApplyT(func(v JvmHeapRuleConfigArgs) *bool { return v.PreferContainerSupport }).(pulumi.BoolPtrOutput) } -// Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. -func (o KubeletConfigurationArgsOutput) SystemReserved() pulumi.StringMapOutput { - return o.ApplyT(func(v KubeletConfigurationArgs) map[string]string { return v.SystemReserved }).(pulumi.StringMapOutput) +// Percentile of usage data used as the heap sizing target (0-1). Example: 0.95. +func (o JvmHeapRuleConfigArgsOutput) TargetPercentile() pulumi.Float64PtrOutput { + return o.ApplyT(func(v JvmHeapRuleConfigArgs) *float64 { return v.TargetPercentile }).(pulumi.Float64PtrOutput) } -type KubeletConfigurationArgsPtrOutput struct{ *pulumi.OutputState } +type JvmHeapRuleConfigArgsPtrOutput struct{ *pulumi.OutputState } -func (KubeletConfigurationArgsPtrOutput) ElementType() reflect.Type { - return reflect.TypeOf((**KubeletConfigurationArgs)(nil)).Elem() +func (JvmHeapRuleConfigArgsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**JvmHeapRuleConfigArgs)(nil)).Elem() } -func (o KubeletConfigurationArgsPtrOutput) ToKubeletConfigurationArgsPtrOutput() KubeletConfigurationArgsPtrOutput { +func (o JvmHeapRuleConfigArgsPtrOutput) ToJvmHeapRuleConfigArgsPtrOutput() JvmHeapRuleConfigArgsPtrOutput { return o } -func (o KubeletConfigurationArgsPtrOutput) ToKubeletConfigurationArgsPtrOutputWithContext(ctx context.Context) KubeletConfigurationArgsPtrOutput { +func (o JvmHeapRuleConfigArgsPtrOutput) ToJvmHeapRuleConfigArgsPtrOutputWithContext(ctx context.Context) JvmHeapRuleConfigArgsPtrOutput { return o } -func (o KubeletConfigurationArgsPtrOutput) Elem() KubeletConfigurationArgsOutput { - return o.ApplyT(func(v *KubeletConfigurationArgs) KubeletConfigurationArgs { +func (o JvmHeapRuleConfigArgsPtrOutput) Elem() JvmHeapRuleConfigArgsOutput { + return o.ApplyT(func(v *JvmHeapRuleConfigArgs) JvmHeapRuleConfigArgs { if v != nil { return *v } - var ret KubeletConfigurationArgs + var ret JvmHeapRuleConfigArgs return ret - }).(KubeletConfigurationArgsOutput) -} - -// DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. -func (o KubeletConfigurationArgsPtrOutput) ClusterDns() pulumi.StringArrayOutput { - return o.ApplyT(func(v *KubeletConfigurationArgs) []string { - if v == nil { - return nil - } - return v.ClusterDns - }).(pulumi.StringArrayOutput) + }).(JvmHeapRuleConfigArgsOutput) } -// Whether to enforce CPU CFS quota limits for containers. Example: true. -func (o KubeletConfigurationArgsPtrOutput) CpuCfsQuota() pulumi.BoolPtrOutput { - return o.ApplyT(func(v *KubeletConfigurationArgs) *bool { +// Enable JVM heap sizing overrides. Example: true. +func (o JvmHeapRuleConfigArgsPtrOutput) Enabled() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *JvmHeapRuleConfigArgs) *bool { if v == nil { return nil } - return v.CpuCfsQuota + return v.Enabled }).(pulumi.BoolPtrOutput) } -// Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. -func (o KubeletConfigurationArgsPtrOutput) EvictionHard() pulumi.StringMapOutput { - return o.ApplyT(func(v *KubeletConfigurationArgs) map[string]string { +// Multiplier applied above the target usage to derive the heap size. Example: 1.3. +func (o JvmHeapRuleConfigArgsPtrOutput) HeadroomMultiplier() pulumi.Float64PtrOutput { + return o.ApplyT(func(v *JvmHeapRuleConfigArgs) *float64 { if v == nil { return nil } - return v.EvictionHard - }).(pulumi.StringMapOutput) + return v.HeadroomMultiplier + }).(pulumi.Float64PtrOutput) } -// Maximum pod termination grace period (seconds) during eviction. Example: 90. -func (o KubeletConfigurationArgsPtrOutput) EvictionMaxPodGracePeriod() pulumi.IntPtrOutput { - return o.ApplyT(func(v *KubeletConfigurationArgs) *int { +// Maximum JVM heap size in bytes. Example: 2147483648. +func (o JvmHeapRuleConfigArgsPtrOutput) MaxHeapBytes() pulumi.IntPtrOutput { + return o.ApplyT(func(v *JvmHeapRuleConfigArgs) *int { if v == nil { return nil } - return v.EvictionMaxPodGracePeriod + return v.MaxHeapBytes }).(pulumi.IntPtrOutput) } -// Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. -func (o KubeletConfigurationArgsPtrOutput) EvictionSoft() pulumi.StringMapOutput { - return o.ApplyT(func(v *KubeletConfigurationArgs) map[string]string { - if v == nil { - return nil - } - return v.EvictionSoft - }).(pulumi.StringMapOutput) -} - -// Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. -func (o KubeletConfigurationArgsPtrOutput) EvictionSoftGracePeriod() pulumi.StringMapOutput { - return o.ApplyT(func(v *KubeletConfigurationArgs) map[string]string { - if v == nil { - return nil - } - return v.EvictionSoftGracePeriod - }).(pulumi.StringMapOutput) -} - -// Disk usage % that triggers image garbage collection. Example: 85. -func (o KubeletConfigurationArgsPtrOutput) ImageGcHighThresholdPercent() pulumi.IntPtrOutput { - return o.ApplyT(func(v *KubeletConfigurationArgs) *int { +// Minimum JVM heap size in bytes. Example: 134217728. +func (o JvmHeapRuleConfigArgsPtrOutput) MinHeapBytes() pulumi.IntPtrOutput { + return o.ApplyT(func(v *JvmHeapRuleConfigArgs) *int { if v == nil { return nil } - return v.ImageGcHighThresholdPercent + return v.MinHeapBytes }).(pulumi.IntPtrOutput) } -// Disk usage % at which image GC stops freeing space. Example: 70. -func (o KubeletConfigurationArgsPtrOutput) ImageGcLowThresholdPercent() pulumi.IntPtrOutput { - return o.ApplyT(func(v *KubeletConfigurationArgs) *int { +// Non-heap memory overhead in bytes. Takes precedence over nonHeapOverheadPercent when set. Example: 268435456. +func (o JvmHeapRuleConfigArgsPtrOutput) NonHeapOverheadBytes() pulumi.IntPtrOutput { + return o.ApplyT(func(v *JvmHeapRuleConfigArgs) *int { if v == nil { return nil } - return v.ImageGcLowThresholdPercent + return v.NonHeapOverheadBytes }).(pulumi.IntPtrOutput) } -// Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. -func (o KubeletConfigurationArgsPtrOutput) KubeReserved() pulumi.StringMapOutput { - return o.ApplyT(func(v *KubeletConfigurationArgs) map[string]string { - if v == nil { - return nil - } - return v.KubeReserved - }).(pulumi.StringMapOutput) -} - -// Maximum number of pods allowed per node. Example: 110. -func (o KubeletConfigurationArgsPtrOutput) MaxPods() pulumi.IntPtrOutput { - return o.ApplyT(func(v *KubeletConfigurationArgs) *int { +// Non-heap memory overhead as a percentage of container memory (0-1). Example: 0.2. +func (o JvmHeapRuleConfigArgsPtrOutput) NonHeapOverheadPercent() pulumi.Float64PtrOutput { + return o.ApplyT(func(v *JvmHeapRuleConfigArgs) *float64 { if v == nil { return nil } - return v.MaxPods - }).(pulumi.IntPtrOutput) + return v.NonHeapOverheadPercent + }).(pulumi.Float64PtrOutput) } -// Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. -func (o KubeletConfigurationArgsPtrOutput) PodsPerCore() pulumi.IntPtrOutput { - return o.ApplyT(func(v *KubeletConfigurationArgs) *int { +// Prefer the JVM's native container-aware heap sizing (-XX:+UseContainerSupport) over explicit -Xmx/-Xms flags. Example: false. +func (o JvmHeapRuleConfigArgsPtrOutput) PreferContainerSupport() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *JvmHeapRuleConfigArgs) *bool { if v == nil { return nil } - return v.PodsPerCore - }).(pulumi.IntPtrOutput) + return v.PreferContainerSupport + }).(pulumi.BoolPtrOutput) } -// Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. -func (o KubeletConfigurationArgsPtrOutput) SystemReserved() pulumi.StringMapOutput { - return o.ApplyT(func(v *KubeletConfigurationArgs) map[string]string { +// Percentile of usage data used as the heap sizing target (0-1). Example: 0.95. +func (o JvmHeapRuleConfigArgsPtrOutput) TargetPercentile() pulumi.Float64PtrOutput { + return o.ApplyT(func(v *JvmHeapRuleConfigArgs) *float64 { if v == nil { return nil } - return v.SystemReserved - }).(pulumi.StringMapOutput) + return v.TargetPercentile + }).(pulumi.Float64PtrOutput) } -type LabelSelectorArgs struct { - // List of label selector requirements joined by AND. - MatchExpressions []LabelSelectorRequirementArgs `pulumi:"matchExpressions"` - // Map of label key-value pairs that must all match exactly. - MatchLabels map[string]string `pulumi:"matchLabels"` +type KedaAdvancedArgs struct { + // Kubernetes HorizontalPodAutoscalerBehavior encoded as a JSON string, applied to the generated HPA. Example: '{"scaleDown":{"stabilizationWindowSeconds":300}}'. + AdvancedBehaviorJson *string `pulumi:"advancedBehaviorJson"` + // Restore the original replica count when the ScaledObject is deleted. Example: false. + RestoreToOriginalReplicaCount *bool `pulumi:"restoreToOriginalReplicaCount"` } -// LabelSelectorArgsInput is an input type that accepts LabelSelectorArgsArgs and LabelSelectorArgsOutput values. -// You can construct a concrete instance of `LabelSelectorArgsInput` via: +// KedaAdvancedArgsInput is an input type that accepts KedaAdvancedArgsArgs and KedaAdvancedArgsOutput values. +// You can construct a concrete instance of `KedaAdvancedArgsInput` via: // -// LabelSelectorArgsArgs{...} -type LabelSelectorArgsInput interface { +// KedaAdvancedArgsArgs{...} +type KedaAdvancedArgsInput interface { pulumi.Input - ToLabelSelectorArgsOutput() LabelSelectorArgsOutput - ToLabelSelectorArgsOutputWithContext(context.Context) LabelSelectorArgsOutput + ToKedaAdvancedArgsOutput() KedaAdvancedArgsOutput + ToKedaAdvancedArgsOutputWithContext(context.Context) KedaAdvancedArgsOutput } -type LabelSelectorArgsArgs struct { - // List of label selector requirements joined by AND. - MatchExpressions LabelSelectorRequirementArgsArrayInput `pulumi:"matchExpressions"` - // Map of label key-value pairs that must all match exactly. - MatchLabels pulumi.StringMapInput `pulumi:"matchLabels"` +type KedaAdvancedArgsArgs struct { + // Kubernetes HorizontalPodAutoscalerBehavior encoded as a JSON string, applied to the generated HPA. Example: '{"scaleDown":{"stabilizationWindowSeconds":300}}'. + AdvancedBehaviorJson pulumi.StringPtrInput `pulumi:"advancedBehaviorJson"` + // Restore the original replica count when the ScaledObject is deleted. Example: false. + RestoreToOriginalReplicaCount pulumi.BoolPtrInput `pulumi:"restoreToOriginalReplicaCount"` } -func (LabelSelectorArgsArgs) ElementType() reflect.Type { - return reflect.TypeOf((*LabelSelectorArgs)(nil)).Elem() +func (KedaAdvancedArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KedaAdvancedArgs)(nil)).Elem() } -func (i LabelSelectorArgsArgs) ToLabelSelectorArgsOutput() LabelSelectorArgsOutput { - return i.ToLabelSelectorArgsOutputWithContext(context.Background()) +func (i KedaAdvancedArgsArgs) ToKedaAdvancedArgsOutput() KedaAdvancedArgsOutput { + return i.ToKedaAdvancedArgsOutputWithContext(context.Background()) } -func (i LabelSelectorArgsArgs) ToLabelSelectorArgsOutputWithContext(ctx context.Context) LabelSelectorArgsOutput { - return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorArgsOutput) +func (i KedaAdvancedArgsArgs) ToKedaAdvancedArgsOutputWithContext(ctx context.Context) KedaAdvancedArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(KedaAdvancedArgsOutput) } -func (i LabelSelectorArgsArgs) ToLabelSelectorArgsPtrOutput() LabelSelectorArgsPtrOutput { - return i.ToLabelSelectorArgsPtrOutputWithContext(context.Background()) +func (i KedaAdvancedArgsArgs) ToKedaAdvancedArgsPtrOutput() KedaAdvancedArgsPtrOutput { + return i.ToKedaAdvancedArgsPtrOutputWithContext(context.Background()) } -func (i LabelSelectorArgsArgs) ToLabelSelectorArgsPtrOutputWithContext(ctx context.Context) LabelSelectorArgsPtrOutput { - return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorArgsOutput).ToLabelSelectorArgsPtrOutputWithContext(ctx) +func (i KedaAdvancedArgsArgs) ToKedaAdvancedArgsPtrOutputWithContext(ctx context.Context) KedaAdvancedArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KedaAdvancedArgsOutput).ToKedaAdvancedArgsPtrOutputWithContext(ctx) } -// LabelSelectorArgsPtrInput is an input type that accepts LabelSelectorArgsArgs, LabelSelectorArgsPtr and LabelSelectorArgsPtrOutput values. -// You can construct a concrete instance of `LabelSelectorArgsPtrInput` via: +// KedaAdvancedArgsPtrInput is an input type that accepts KedaAdvancedArgsArgs, KedaAdvancedArgsPtr and KedaAdvancedArgsPtrOutput values. +// You can construct a concrete instance of `KedaAdvancedArgsPtrInput` via: // -// LabelSelectorArgsArgs{...} +// KedaAdvancedArgsArgs{...} // // or: // // nil -type LabelSelectorArgsPtrInput interface { +type KedaAdvancedArgsPtrInput interface { pulumi.Input - ToLabelSelectorArgsPtrOutput() LabelSelectorArgsPtrOutput - ToLabelSelectorArgsPtrOutputWithContext(context.Context) LabelSelectorArgsPtrOutput + ToKedaAdvancedArgsPtrOutput() KedaAdvancedArgsPtrOutput + ToKedaAdvancedArgsPtrOutputWithContext(context.Context) KedaAdvancedArgsPtrOutput } -type labelSelectorArgsPtrType LabelSelectorArgsArgs +type kedaAdvancedArgsPtrType KedaAdvancedArgsArgs -func LabelSelectorArgsPtr(v *LabelSelectorArgsArgs) LabelSelectorArgsPtrInput { - return (*labelSelectorArgsPtrType)(v) +func KedaAdvancedArgsPtr(v *KedaAdvancedArgsArgs) KedaAdvancedArgsPtrInput { + return (*kedaAdvancedArgsPtrType)(v) } -func (*labelSelectorArgsPtrType) ElementType() reflect.Type { - return reflect.TypeOf((**LabelSelectorArgs)(nil)).Elem() +func (*kedaAdvancedArgsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KedaAdvancedArgs)(nil)).Elem() } -func (i *labelSelectorArgsPtrType) ToLabelSelectorArgsPtrOutput() LabelSelectorArgsPtrOutput { - return i.ToLabelSelectorArgsPtrOutputWithContext(context.Background()) +func (i *kedaAdvancedArgsPtrType) ToKedaAdvancedArgsPtrOutput() KedaAdvancedArgsPtrOutput { + return i.ToKedaAdvancedArgsPtrOutputWithContext(context.Background()) } -func (i *labelSelectorArgsPtrType) ToLabelSelectorArgsPtrOutputWithContext(ctx context.Context) LabelSelectorArgsPtrOutput { - return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorArgsPtrOutput) +func (i *kedaAdvancedArgsPtrType) ToKedaAdvancedArgsPtrOutputWithContext(ctx context.Context) KedaAdvancedArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KedaAdvancedArgsPtrOutput) } -type LabelSelectorArgsOutput struct{ *pulumi.OutputState } +type KedaAdvancedArgsOutput struct{ *pulumi.OutputState } -func (LabelSelectorArgsOutput) ElementType() reflect.Type { - return reflect.TypeOf((*LabelSelectorArgs)(nil)).Elem() +func (KedaAdvancedArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KedaAdvancedArgs)(nil)).Elem() } -func (o LabelSelectorArgsOutput) ToLabelSelectorArgsOutput() LabelSelectorArgsOutput { +func (o KedaAdvancedArgsOutput) ToKedaAdvancedArgsOutput() KedaAdvancedArgsOutput { return o } -func (o LabelSelectorArgsOutput) ToLabelSelectorArgsOutputWithContext(ctx context.Context) LabelSelectorArgsOutput { +func (o KedaAdvancedArgsOutput) ToKedaAdvancedArgsOutputWithContext(ctx context.Context) KedaAdvancedArgsOutput { return o } -func (o LabelSelectorArgsOutput) ToLabelSelectorArgsPtrOutput() LabelSelectorArgsPtrOutput { - return o.ToLabelSelectorArgsPtrOutputWithContext(context.Background()) +func (o KedaAdvancedArgsOutput) ToKedaAdvancedArgsPtrOutput() KedaAdvancedArgsPtrOutput { + return o.ToKedaAdvancedArgsPtrOutputWithContext(context.Background()) } -func (o LabelSelectorArgsOutput) ToLabelSelectorArgsPtrOutputWithContext(ctx context.Context) LabelSelectorArgsPtrOutput { - return o.ApplyTWithContext(ctx, func(_ context.Context, v LabelSelectorArgs) *LabelSelectorArgs { +func (o KedaAdvancedArgsOutput) ToKedaAdvancedArgsPtrOutputWithContext(ctx context.Context) KedaAdvancedArgsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KedaAdvancedArgs) *KedaAdvancedArgs { return &v - }).(LabelSelectorArgsPtrOutput) + }).(KedaAdvancedArgsPtrOutput) } -// List of label selector requirements joined by AND. -func (o LabelSelectorArgsOutput) MatchExpressions() LabelSelectorRequirementArgsArrayOutput { - return o.ApplyT(func(v LabelSelectorArgs) []LabelSelectorRequirementArgs { return v.MatchExpressions }).(LabelSelectorRequirementArgsArrayOutput) +// Kubernetes HorizontalPodAutoscalerBehavior encoded as a JSON string, applied to the generated HPA. Example: '{"scaleDown":{"stabilizationWindowSeconds":300}}'. +func (o KedaAdvancedArgsOutput) AdvancedBehaviorJson() pulumi.StringPtrOutput { + return o.ApplyT(func(v KedaAdvancedArgs) *string { return v.AdvancedBehaviorJson }).(pulumi.StringPtrOutput) } -// Map of label key-value pairs that must all match exactly. -func (o LabelSelectorArgsOutput) MatchLabels() pulumi.StringMapOutput { - return o.ApplyT(func(v LabelSelectorArgs) map[string]string { return v.MatchLabels }).(pulumi.StringMapOutput) +// Restore the original replica count when the ScaledObject is deleted. Example: false. +func (o KedaAdvancedArgsOutput) RestoreToOriginalReplicaCount() pulumi.BoolPtrOutput { + return o.ApplyT(func(v KedaAdvancedArgs) *bool { return v.RestoreToOriginalReplicaCount }).(pulumi.BoolPtrOutput) } -type LabelSelectorArgsPtrOutput struct{ *pulumi.OutputState } +type KedaAdvancedArgsPtrOutput struct{ *pulumi.OutputState } -func (LabelSelectorArgsPtrOutput) ElementType() reflect.Type { - return reflect.TypeOf((**LabelSelectorArgs)(nil)).Elem() +func (KedaAdvancedArgsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KedaAdvancedArgs)(nil)).Elem() } -func (o LabelSelectorArgsPtrOutput) ToLabelSelectorArgsPtrOutput() LabelSelectorArgsPtrOutput { +func (o KedaAdvancedArgsPtrOutput) ToKedaAdvancedArgsPtrOutput() KedaAdvancedArgsPtrOutput { return o } -func (o LabelSelectorArgsPtrOutput) ToLabelSelectorArgsPtrOutputWithContext(ctx context.Context) LabelSelectorArgsPtrOutput { +func (o KedaAdvancedArgsPtrOutput) ToKedaAdvancedArgsPtrOutputWithContext(ctx context.Context) KedaAdvancedArgsPtrOutput { return o } -func (o LabelSelectorArgsPtrOutput) Elem() LabelSelectorArgsOutput { - return o.ApplyT(func(v *LabelSelectorArgs) LabelSelectorArgs { +func (o KedaAdvancedArgsPtrOutput) Elem() KedaAdvancedArgsOutput { + return o.ApplyT(func(v *KedaAdvancedArgs) KedaAdvancedArgs { if v != nil { return *v } - var ret LabelSelectorArgs + var ret KedaAdvancedArgs return ret - }).(LabelSelectorArgsOutput) + }).(KedaAdvancedArgsOutput) } -// List of label selector requirements joined by AND. -func (o LabelSelectorArgsPtrOutput) MatchExpressions() LabelSelectorRequirementArgsArrayOutput { - return o.ApplyT(func(v *LabelSelectorArgs) []LabelSelectorRequirementArgs { +// Kubernetes HorizontalPodAutoscalerBehavior encoded as a JSON string, applied to the generated HPA. Example: '{"scaleDown":{"stabilizationWindowSeconds":300}}'. +func (o KedaAdvancedArgsPtrOutput) AdvancedBehaviorJson() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KedaAdvancedArgs) *string { if v == nil { return nil } - return v.MatchExpressions - }).(LabelSelectorRequirementArgsArrayOutput) + return v.AdvancedBehaviorJson + }).(pulumi.StringPtrOutput) } -// Map of label key-value pairs that must all match exactly. -func (o LabelSelectorArgsPtrOutput) MatchLabels() pulumi.StringMapOutput { - return o.ApplyT(func(v *LabelSelectorArgs) map[string]string { +// Restore the original replica count when the ScaledObject is deleted. Example: false. +func (o KedaAdvancedArgsPtrOutput) RestoreToOriginalReplicaCount() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *KedaAdvancedArgs) *bool { if v == nil { return nil } - return v.MatchLabels - }).(pulumi.StringMapOutput) + return v.RestoreToOriginalReplicaCount + }).(pulumi.BoolPtrOutput) } -type LabelSelectorRequirementArgs struct { - // The label key that the selector applies to. - Key *string `pulumi:"key"` - // Operator relating the key and values. One of: 'In', 'NotIn', 'Exists', 'DoesNotExist'. - Operator *string `pulumi:"operator"` - // Array of string values. Required for 'In' and 'NotIn' operators. - Values []string `pulumi:"values"` +type KedaAuthenticationRefArgs struct { + // Kind of the referenced resource. One of: 'TriggerAuthentication', 'ClusterTriggerAuthentication'. Example: 'TriggerAuthentication'. + Kind *string `pulumi:"kind"` + // Name of the referenced TriggerAuthentication/ClusterTriggerAuthentication resource. Example: 'prometheus-auth'. + Name string `pulumi:"name"` } -// LabelSelectorRequirementArgsInput is an input type that accepts LabelSelectorRequirementArgsArgs and LabelSelectorRequirementArgsOutput values. -// You can construct a concrete instance of `LabelSelectorRequirementArgsInput` via: +// KedaAuthenticationRefArgsInput is an input type that accepts KedaAuthenticationRefArgsArgs and KedaAuthenticationRefArgsOutput values. +// You can construct a concrete instance of `KedaAuthenticationRefArgsInput` via: // -// LabelSelectorRequirementArgsArgs{...} -type LabelSelectorRequirementArgsInput interface { +// KedaAuthenticationRefArgsArgs{...} +type KedaAuthenticationRefArgsInput interface { pulumi.Input - ToLabelSelectorRequirementArgsOutput() LabelSelectorRequirementArgsOutput - ToLabelSelectorRequirementArgsOutputWithContext(context.Context) LabelSelectorRequirementArgsOutput + ToKedaAuthenticationRefArgsOutput() KedaAuthenticationRefArgsOutput + ToKedaAuthenticationRefArgsOutputWithContext(context.Context) KedaAuthenticationRefArgsOutput } -type LabelSelectorRequirementArgsArgs struct { - // The label key that the selector applies to. - Key pulumi.StringPtrInput `pulumi:"key"` - // Operator relating the key and values. One of: 'In', 'NotIn', 'Exists', 'DoesNotExist'. - Operator pulumi.StringPtrInput `pulumi:"operator"` - // Array of string values. Required for 'In' and 'NotIn' operators. - Values pulumi.StringArrayInput `pulumi:"values"` +type KedaAuthenticationRefArgsArgs struct { + // Kind of the referenced resource. One of: 'TriggerAuthentication', 'ClusterTriggerAuthentication'. Example: 'TriggerAuthentication'. + Kind pulumi.StringPtrInput `pulumi:"kind"` + // Name of the referenced TriggerAuthentication/ClusterTriggerAuthentication resource. Example: 'prometheus-auth'. + Name pulumi.StringInput `pulumi:"name"` } -func (LabelSelectorRequirementArgsArgs) ElementType() reflect.Type { - return reflect.TypeOf((*LabelSelectorRequirementArgs)(nil)).Elem() +func (KedaAuthenticationRefArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KedaAuthenticationRefArgs)(nil)).Elem() } -func (i LabelSelectorRequirementArgsArgs) ToLabelSelectorRequirementArgsOutput() LabelSelectorRequirementArgsOutput { - return i.ToLabelSelectorRequirementArgsOutputWithContext(context.Background()) +func (i KedaAuthenticationRefArgsArgs) ToKedaAuthenticationRefArgsOutput() KedaAuthenticationRefArgsOutput { + return i.ToKedaAuthenticationRefArgsOutputWithContext(context.Background()) } -func (i LabelSelectorRequirementArgsArgs) ToLabelSelectorRequirementArgsOutputWithContext(ctx context.Context) LabelSelectorRequirementArgsOutput { - return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorRequirementArgsOutput) +func (i KedaAuthenticationRefArgsArgs) ToKedaAuthenticationRefArgsOutputWithContext(ctx context.Context) KedaAuthenticationRefArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(KedaAuthenticationRefArgsOutput) } -// LabelSelectorRequirementArgsArrayInput is an input type that accepts LabelSelectorRequirementArgsArray and LabelSelectorRequirementArgsArrayOutput values. -// You can construct a concrete instance of `LabelSelectorRequirementArgsArrayInput` via: +func (i KedaAuthenticationRefArgsArgs) ToKedaAuthenticationRefArgsPtrOutput() KedaAuthenticationRefArgsPtrOutput { + return i.ToKedaAuthenticationRefArgsPtrOutputWithContext(context.Background()) +} + +func (i KedaAuthenticationRefArgsArgs) ToKedaAuthenticationRefArgsPtrOutputWithContext(ctx context.Context) KedaAuthenticationRefArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KedaAuthenticationRefArgsOutput).ToKedaAuthenticationRefArgsPtrOutputWithContext(ctx) +} + +// KedaAuthenticationRefArgsPtrInput is an input type that accepts KedaAuthenticationRefArgsArgs, KedaAuthenticationRefArgsPtr and KedaAuthenticationRefArgsPtrOutput values. +// You can construct a concrete instance of `KedaAuthenticationRefArgsPtrInput` via: // -// LabelSelectorRequirementArgsArray{ LabelSelectorRequirementArgsArgs{...} } -type LabelSelectorRequirementArgsArrayInput interface { +// KedaAuthenticationRefArgsArgs{...} +// +// or: +// +// nil +type KedaAuthenticationRefArgsPtrInput interface { pulumi.Input - ToLabelSelectorRequirementArgsArrayOutput() LabelSelectorRequirementArgsArrayOutput - ToLabelSelectorRequirementArgsArrayOutputWithContext(context.Context) LabelSelectorRequirementArgsArrayOutput + ToKedaAuthenticationRefArgsPtrOutput() KedaAuthenticationRefArgsPtrOutput + ToKedaAuthenticationRefArgsPtrOutputWithContext(context.Context) KedaAuthenticationRefArgsPtrOutput } -type LabelSelectorRequirementArgsArray []LabelSelectorRequirementArgsInput +type kedaAuthenticationRefArgsPtrType KedaAuthenticationRefArgsArgs -func (LabelSelectorRequirementArgsArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]LabelSelectorRequirementArgs)(nil)).Elem() +func KedaAuthenticationRefArgsPtr(v *KedaAuthenticationRefArgsArgs) KedaAuthenticationRefArgsPtrInput { + return (*kedaAuthenticationRefArgsPtrType)(v) } -func (i LabelSelectorRequirementArgsArray) ToLabelSelectorRequirementArgsArrayOutput() LabelSelectorRequirementArgsArrayOutput { - return i.ToLabelSelectorRequirementArgsArrayOutputWithContext(context.Background()) +func (*kedaAuthenticationRefArgsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KedaAuthenticationRefArgs)(nil)).Elem() } -func (i LabelSelectorRequirementArgsArray) ToLabelSelectorRequirementArgsArrayOutputWithContext(ctx context.Context) LabelSelectorRequirementArgsArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorRequirementArgsArrayOutput) +func (i *kedaAuthenticationRefArgsPtrType) ToKedaAuthenticationRefArgsPtrOutput() KedaAuthenticationRefArgsPtrOutput { + return i.ToKedaAuthenticationRefArgsPtrOutputWithContext(context.Background()) } -type LabelSelectorRequirementArgsOutput struct{ *pulumi.OutputState } +func (i *kedaAuthenticationRefArgsPtrType) ToKedaAuthenticationRefArgsPtrOutputWithContext(ctx context.Context) KedaAuthenticationRefArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KedaAuthenticationRefArgsPtrOutput) +} -func (LabelSelectorRequirementArgsOutput) ElementType() reflect.Type { - return reflect.TypeOf((*LabelSelectorRequirementArgs)(nil)).Elem() +type KedaAuthenticationRefArgsOutput struct{ *pulumi.OutputState } + +func (KedaAuthenticationRefArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KedaAuthenticationRefArgs)(nil)).Elem() } -func (o LabelSelectorRequirementArgsOutput) ToLabelSelectorRequirementArgsOutput() LabelSelectorRequirementArgsOutput { +func (o KedaAuthenticationRefArgsOutput) ToKedaAuthenticationRefArgsOutput() KedaAuthenticationRefArgsOutput { return o } -func (o LabelSelectorRequirementArgsOutput) ToLabelSelectorRequirementArgsOutputWithContext(ctx context.Context) LabelSelectorRequirementArgsOutput { +func (o KedaAuthenticationRefArgsOutput) ToKedaAuthenticationRefArgsOutputWithContext(ctx context.Context) KedaAuthenticationRefArgsOutput { return o } -// The label key that the selector applies to. -func (o LabelSelectorRequirementArgsOutput) Key() pulumi.StringPtrOutput { - return o.ApplyT(func(v LabelSelectorRequirementArgs) *string { return v.Key }).(pulumi.StringPtrOutput) +func (o KedaAuthenticationRefArgsOutput) ToKedaAuthenticationRefArgsPtrOutput() KedaAuthenticationRefArgsPtrOutput { + return o.ToKedaAuthenticationRefArgsPtrOutputWithContext(context.Background()) } -// Operator relating the key and values. One of: 'In', 'NotIn', 'Exists', 'DoesNotExist'. -func (o LabelSelectorRequirementArgsOutput) Operator() pulumi.StringPtrOutput { - return o.ApplyT(func(v LabelSelectorRequirementArgs) *string { return v.Operator }).(pulumi.StringPtrOutput) +func (o KedaAuthenticationRefArgsOutput) ToKedaAuthenticationRefArgsPtrOutputWithContext(ctx context.Context) KedaAuthenticationRefArgsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KedaAuthenticationRefArgs) *KedaAuthenticationRefArgs { + return &v + }).(KedaAuthenticationRefArgsPtrOutput) } -// Array of string values. Required for 'In' and 'NotIn' operators. -func (o LabelSelectorRequirementArgsOutput) Values() pulumi.StringArrayOutput { - return o.ApplyT(func(v LabelSelectorRequirementArgs) []string { return v.Values }).(pulumi.StringArrayOutput) +// Kind of the referenced resource. One of: 'TriggerAuthentication', 'ClusterTriggerAuthentication'. Example: 'TriggerAuthentication'. +func (o KedaAuthenticationRefArgsOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v KedaAuthenticationRefArgs) *string { return v.Kind }).(pulumi.StringPtrOutput) } -type LabelSelectorRequirementArgsArrayOutput struct{ *pulumi.OutputState } +// Name of the referenced TriggerAuthentication/ClusterTriggerAuthentication resource. Example: 'prometheus-auth'. +func (o KedaAuthenticationRefArgsOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v KedaAuthenticationRefArgs) string { return v.Name }).(pulumi.StringOutput) +} -func (LabelSelectorRequirementArgsArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]LabelSelectorRequirementArgs)(nil)).Elem() +type KedaAuthenticationRefArgsPtrOutput struct{ *pulumi.OutputState } + +func (KedaAuthenticationRefArgsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KedaAuthenticationRefArgs)(nil)).Elem() } -func (o LabelSelectorRequirementArgsArrayOutput) ToLabelSelectorRequirementArgsArrayOutput() LabelSelectorRequirementArgsArrayOutput { +func (o KedaAuthenticationRefArgsPtrOutput) ToKedaAuthenticationRefArgsPtrOutput() KedaAuthenticationRefArgsPtrOutput { return o } -func (o LabelSelectorRequirementArgsArrayOutput) ToLabelSelectorRequirementArgsArrayOutputWithContext(ctx context.Context) LabelSelectorRequirementArgsArrayOutput { +func (o KedaAuthenticationRefArgsPtrOutput) ToKedaAuthenticationRefArgsPtrOutputWithContext(ctx context.Context) KedaAuthenticationRefArgsPtrOutput { return o } -func (o LabelSelectorRequirementArgsArrayOutput) Index(i pulumi.IntInput) LabelSelectorRequirementArgsOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) LabelSelectorRequirementArgs { - return vs[0].([]LabelSelectorRequirementArgs)[vs[1].(int)] - }).(LabelSelectorRequirementArgsOutput) +func (o KedaAuthenticationRefArgsPtrOutput) Elem() KedaAuthenticationRefArgsOutput { + return o.ApplyT(func(v *KedaAuthenticationRefArgs) KedaAuthenticationRefArgs { + if v != nil { + return *v + } + var ret KedaAuthenticationRefArgs + return ret + }).(KedaAuthenticationRefArgsOutput) } -type MetadataOptionsArgs struct { - // Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. - HttpEndpoint *string `pulumi:"httpEndpoint"` - // Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. - HttpProtocolIpv6 *string `pulumi:"httpProtocolIpv6"` - // HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. - HttpPutResponseHopLimit *int `pulumi:"httpPutResponseHopLimit"` - // Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. - HttpTokens *string `pulumi:"httpTokens"` +// Kind of the referenced resource. One of: 'TriggerAuthentication', 'ClusterTriggerAuthentication'. Example: 'TriggerAuthentication'. +func (o KedaAuthenticationRefArgsPtrOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KedaAuthenticationRefArgs) *string { + if v == nil { + return nil + } + return v.Kind + }).(pulumi.StringPtrOutput) } -// MetadataOptionsArgsInput is an input type that accepts MetadataOptionsArgsArgs and MetadataOptionsArgsOutput values. -// You can construct a concrete instance of `MetadataOptionsArgsInput` via: +// Name of the referenced TriggerAuthentication/ClusterTriggerAuthentication resource. Example: 'prometheus-auth'. +func (o KedaAuthenticationRefArgsPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KedaAuthenticationRefArgs) *string { + if v == nil { + return nil + } + return &v.Name + }).(pulumi.StringPtrOutput) +} + +type KedaFallbackArgs struct { + // Fallback strategy. Example: 'static'. + Behavior *string `pulumi:"behavior"` + // Number of consecutive metric failures before activating fallback. Example: 3. + FailureThreshold int `pulumi:"failureThreshold"` + // Number of replicas to fall back to when metrics are unavailable. Example: 2. + Replicas int `pulumi:"replicas"` +} + +// KedaFallbackArgsInput is an input type that accepts KedaFallbackArgsArgs and KedaFallbackArgsOutput values. +// You can construct a concrete instance of `KedaFallbackArgsInput` via: // -// MetadataOptionsArgsArgs{...} -type MetadataOptionsArgsInput interface { +// KedaFallbackArgsArgs{...} +type KedaFallbackArgsInput interface { pulumi.Input - ToMetadataOptionsArgsOutput() MetadataOptionsArgsOutput - ToMetadataOptionsArgsOutputWithContext(context.Context) MetadataOptionsArgsOutput + ToKedaFallbackArgsOutput() KedaFallbackArgsOutput + ToKedaFallbackArgsOutputWithContext(context.Context) KedaFallbackArgsOutput } -type MetadataOptionsArgsArgs struct { - // Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. - HttpEndpoint pulumi.StringPtrInput `pulumi:"httpEndpoint"` - // Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. - HttpProtocolIpv6 pulumi.StringPtrInput `pulumi:"httpProtocolIpv6"` - // HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. - HttpPutResponseHopLimit pulumi.IntPtrInput `pulumi:"httpPutResponseHopLimit"` - // Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. - HttpTokens pulumi.StringPtrInput `pulumi:"httpTokens"` +type KedaFallbackArgsArgs struct { + // Fallback strategy. Example: 'static'. + Behavior pulumi.StringPtrInput `pulumi:"behavior"` + // Number of consecutive metric failures before activating fallback. Example: 3. + FailureThreshold pulumi.IntInput `pulumi:"failureThreshold"` + // Number of replicas to fall back to when metrics are unavailable. Example: 2. + Replicas pulumi.IntInput `pulumi:"replicas"` } -func (MetadataOptionsArgsArgs) ElementType() reflect.Type { - return reflect.TypeOf((*MetadataOptionsArgs)(nil)).Elem() +func (KedaFallbackArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KedaFallbackArgs)(nil)).Elem() } -func (i MetadataOptionsArgsArgs) ToMetadataOptionsArgsOutput() MetadataOptionsArgsOutput { - return i.ToMetadataOptionsArgsOutputWithContext(context.Background()) +func (i KedaFallbackArgsArgs) ToKedaFallbackArgsOutput() KedaFallbackArgsOutput { + return i.ToKedaFallbackArgsOutputWithContext(context.Background()) } -func (i MetadataOptionsArgsArgs) ToMetadataOptionsArgsOutputWithContext(ctx context.Context) MetadataOptionsArgsOutput { - return pulumi.ToOutputWithContext(ctx, i).(MetadataOptionsArgsOutput) +func (i KedaFallbackArgsArgs) ToKedaFallbackArgsOutputWithContext(ctx context.Context) KedaFallbackArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(KedaFallbackArgsOutput) } -func (i MetadataOptionsArgsArgs) ToMetadataOptionsArgsPtrOutput() MetadataOptionsArgsPtrOutput { - return i.ToMetadataOptionsArgsPtrOutputWithContext(context.Background()) +func (i KedaFallbackArgsArgs) ToKedaFallbackArgsPtrOutput() KedaFallbackArgsPtrOutput { + return i.ToKedaFallbackArgsPtrOutputWithContext(context.Background()) } -func (i MetadataOptionsArgsArgs) ToMetadataOptionsArgsPtrOutputWithContext(ctx context.Context) MetadataOptionsArgsPtrOutput { - return pulumi.ToOutputWithContext(ctx, i).(MetadataOptionsArgsOutput).ToMetadataOptionsArgsPtrOutputWithContext(ctx) +func (i KedaFallbackArgsArgs) ToKedaFallbackArgsPtrOutputWithContext(ctx context.Context) KedaFallbackArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KedaFallbackArgsOutput).ToKedaFallbackArgsPtrOutputWithContext(ctx) } -// MetadataOptionsArgsPtrInput is an input type that accepts MetadataOptionsArgsArgs, MetadataOptionsArgsPtr and MetadataOptionsArgsPtrOutput values. -// You can construct a concrete instance of `MetadataOptionsArgsPtrInput` via: +// KedaFallbackArgsPtrInput is an input type that accepts KedaFallbackArgsArgs, KedaFallbackArgsPtr and KedaFallbackArgsPtrOutput values. +// You can construct a concrete instance of `KedaFallbackArgsPtrInput` via: // -// MetadataOptionsArgsArgs{...} +// KedaFallbackArgsArgs{...} // // or: // // nil -type MetadataOptionsArgsPtrInput interface { +type KedaFallbackArgsPtrInput interface { pulumi.Input - ToMetadataOptionsArgsPtrOutput() MetadataOptionsArgsPtrOutput - ToMetadataOptionsArgsPtrOutputWithContext(context.Context) MetadataOptionsArgsPtrOutput + ToKedaFallbackArgsPtrOutput() KedaFallbackArgsPtrOutput + ToKedaFallbackArgsPtrOutputWithContext(context.Context) KedaFallbackArgsPtrOutput } -type metadataOptionsArgsPtrType MetadataOptionsArgsArgs +type kedaFallbackArgsPtrType KedaFallbackArgsArgs -func MetadataOptionsArgsPtr(v *MetadataOptionsArgsArgs) MetadataOptionsArgsPtrInput { - return (*metadataOptionsArgsPtrType)(v) +func KedaFallbackArgsPtr(v *KedaFallbackArgsArgs) KedaFallbackArgsPtrInput { + return (*kedaFallbackArgsPtrType)(v) } -func (*metadataOptionsArgsPtrType) ElementType() reflect.Type { - return reflect.TypeOf((**MetadataOptionsArgs)(nil)).Elem() +func (*kedaFallbackArgsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KedaFallbackArgs)(nil)).Elem() } -func (i *metadataOptionsArgsPtrType) ToMetadataOptionsArgsPtrOutput() MetadataOptionsArgsPtrOutput { - return i.ToMetadataOptionsArgsPtrOutputWithContext(context.Background()) +func (i *kedaFallbackArgsPtrType) ToKedaFallbackArgsPtrOutput() KedaFallbackArgsPtrOutput { + return i.ToKedaFallbackArgsPtrOutputWithContext(context.Background()) } -func (i *metadataOptionsArgsPtrType) ToMetadataOptionsArgsPtrOutputWithContext(ctx context.Context) MetadataOptionsArgsPtrOutput { - return pulumi.ToOutputWithContext(ctx, i).(MetadataOptionsArgsPtrOutput) +func (i *kedaFallbackArgsPtrType) ToKedaFallbackArgsPtrOutputWithContext(ctx context.Context) KedaFallbackArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KedaFallbackArgsPtrOutput) } -type MetadataOptionsArgsOutput struct{ *pulumi.OutputState } +type KedaFallbackArgsOutput struct{ *pulumi.OutputState } -func (MetadataOptionsArgsOutput) ElementType() reflect.Type { - return reflect.TypeOf((*MetadataOptionsArgs)(nil)).Elem() +func (KedaFallbackArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KedaFallbackArgs)(nil)).Elem() } -func (o MetadataOptionsArgsOutput) ToMetadataOptionsArgsOutput() MetadataOptionsArgsOutput { +func (o KedaFallbackArgsOutput) ToKedaFallbackArgsOutput() KedaFallbackArgsOutput { return o } -func (o MetadataOptionsArgsOutput) ToMetadataOptionsArgsOutputWithContext(ctx context.Context) MetadataOptionsArgsOutput { +func (o KedaFallbackArgsOutput) ToKedaFallbackArgsOutputWithContext(ctx context.Context) KedaFallbackArgsOutput { return o } -func (o MetadataOptionsArgsOutput) ToMetadataOptionsArgsPtrOutput() MetadataOptionsArgsPtrOutput { - return o.ToMetadataOptionsArgsPtrOutputWithContext(context.Background()) +func (o KedaFallbackArgsOutput) ToKedaFallbackArgsPtrOutput() KedaFallbackArgsPtrOutput { + return o.ToKedaFallbackArgsPtrOutputWithContext(context.Background()) } -func (o MetadataOptionsArgsOutput) ToMetadataOptionsArgsPtrOutputWithContext(ctx context.Context) MetadataOptionsArgsPtrOutput { - return o.ApplyTWithContext(ctx, func(_ context.Context, v MetadataOptionsArgs) *MetadataOptionsArgs { +func (o KedaFallbackArgsOutput) ToKedaFallbackArgsPtrOutputWithContext(ctx context.Context) KedaFallbackArgsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KedaFallbackArgs) *KedaFallbackArgs { return &v - }).(MetadataOptionsArgsPtrOutput) -} - -// Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. -func (o MetadataOptionsArgsOutput) HttpEndpoint() pulumi.StringPtrOutput { - return o.ApplyT(func(v MetadataOptionsArgs) *string { return v.HttpEndpoint }).(pulumi.StringPtrOutput) + }).(KedaFallbackArgsPtrOutput) } -// Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. -func (o MetadataOptionsArgsOutput) HttpProtocolIpv6() pulumi.StringPtrOutput { - return o.ApplyT(func(v MetadataOptionsArgs) *string { return v.HttpProtocolIpv6 }).(pulumi.StringPtrOutput) +// Fallback strategy. Example: 'static'. +func (o KedaFallbackArgsOutput) Behavior() pulumi.StringPtrOutput { + return o.ApplyT(func(v KedaFallbackArgs) *string { return v.Behavior }).(pulumi.StringPtrOutput) } -// HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. -func (o MetadataOptionsArgsOutput) HttpPutResponseHopLimit() pulumi.IntPtrOutput { - return o.ApplyT(func(v MetadataOptionsArgs) *int { return v.HttpPutResponseHopLimit }).(pulumi.IntPtrOutput) +// Number of consecutive metric failures before activating fallback. Example: 3. +func (o KedaFallbackArgsOutput) FailureThreshold() pulumi.IntOutput { + return o.ApplyT(func(v KedaFallbackArgs) int { return v.FailureThreshold }).(pulumi.IntOutput) } -// Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. -func (o MetadataOptionsArgsOutput) HttpTokens() pulumi.StringPtrOutput { - return o.ApplyT(func(v MetadataOptionsArgs) *string { return v.HttpTokens }).(pulumi.StringPtrOutput) +// Number of replicas to fall back to when metrics are unavailable. Example: 2. +func (o KedaFallbackArgsOutput) Replicas() pulumi.IntOutput { + return o.ApplyT(func(v KedaFallbackArgs) int { return v.Replicas }).(pulumi.IntOutput) } -type MetadataOptionsArgsPtrOutput struct{ *pulumi.OutputState } +type KedaFallbackArgsPtrOutput struct{ *pulumi.OutputState } -func (MetadataOptionsArgsPtrOutput) ElementType() reflect.Type { - return reflect.TypeOf((**MetadataOptionsArgs)(nil)).Elem() +func (KedaFallbackArgsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KedaFallbackArgs)(nil)).Elem() } -func (o MetadataOptionsArgsPtrOutput) ToMetadataOptionsArgsPtrOutput() MetadataOptionsArgsPtrOutput { +func (o KedaFallbackArgsPtrOutput) ToKedaFallbackArgsPtrOutput() KedaFallbackArgsPtrOutput { return o } -func (o MetadataOptionsArgsPtrOutput) ToMetadataOptionsArgsPtrOutputWithContext(ctx context.Context) MetadataOptionsArgsPtrOutput { +func (o KedaFallbackArgsPtrOutput) ToKedaFallbackArgsPtrOutputWithContext(ctx context.Context) KedaFallbackArgsPtrOutput { return o } -func (o MetadataOptionsArgsPtrOutput) Elem() MetadataOptionsArgsOutput { - return o.ApplyT(func(v *MetadataOptionsArgs) MetadataOptionsArgs { +func (o KedaFallbackArgsPtrOutput) Elem() KedaFallbackArgsOutput { + return o.ApplyT(func(v *KedaFallbackArgs) KedaFallbackArgs { if v != nil { return *v } - var ret MetadataOptionsArgs + var ret KedaFallbackArgs return ret - }).(MetadataOptionsArgsOutput) + }).(KedaFallbackArgsOutput) } -// Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. -func (o MetadataOptionsArgsPtrOutput) HttpEndpoint() pulumi.StringPtrOutput { - return o.ApplyT(func(v *MetadataOptionsArgs) *string { +// Fallback strategy. Example: 'static'. +func (o KedaFallbackArgsPtrOutput) Behavior() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KedaFallbackArgs) *string { if v == nil { return nil } - return v.HttpEndpoint + return v.Behavior }).(pulumi.StringPtrOutput) } -// Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. -func (o MetadataOptionsArgsPtrOutput) HttpProtocolIpv6() pulumi.StringPtrOutput { - return o.ApplyT(func(v *MetadataOptionsArgs) *string { +// Number of consecutive metric failures before activating fallback. Example: 3. +func (o KedaFallbackArgsPtrOutput) FailureThreshold() pulumi.IntPtrOutput { + return o.ApplyT(func(v *KedaFallbackArgs) *int { if v == nil { return nil } - return v.HttpProtocolIpv6 - }).(pulumi.StringPtrOutput) + return &v.FailureThreshold + }).(pulumi.IntPtrOutput) } -// HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. -func (o MetadataOptionsArgsPtrOutput) HttpPutResponseHopLimit() pulumi.IntPtrOutput { - return o.ApplyT(func(v *MetadataOptionsArgs) *int { +// Number of replicas to fall back to when metrics are unavailable. Example: 2. +func (o KedaFallbackArgsPtrOutput) Replicas() pulumi.IntPtrOutput { + return o.ApplyT(func(v *KedaFallbackArgs) *int { if v == nil { return nil } - return v.HttpPutResponseHopLimit + return &v.Replicas }).(pulumi.IntPtrOutput) } -// Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. -func (o MetadataOptionsArgsPtrOutput) HttpTokens() pulumi.StringPtrOutput { - return o.ApplyT(func(v *MetadataOptionsArgs) *string { - if v == nil { - return nil - } - return v.HttpTokens - }).(pulumi.StringPtrOutput) +type KedaScaledObjectArgs struct { + // Advanced ScaledObject behavior configuration. + Advanced *KedaAdvancedArgs `pulumi:"advanced"` + // Seconds to wait after the last trigger reports active=false before scaling to minReplicaCount. Example: 300. + CooldownPeriod *int `pulumi:"cooldownPeriod"` + // Replica fallback configuration when KEDA metrics are unavailable. + Fallback *KedaFallbackArgs `pulumi:"fallback"` + // Replica count to scale to when idle. Must be less than minReplicaCount. Example: 0. + IdleReplicaCount *int `pulumi:"idleReplicaCount"` + // Cooldown period applied only during the initial scaling of the ScaledObject. Example: 0. + InitialCooldownPeriod *int `pulumi:"initialCooldownPeriod"` + // Maximum number of replicas. Example: 10. + MaxReplicaCount *int `pulumi:"maxReplicaCount"` + // Minimum number of replicas. Example: 0. + MinReplicaCount *int `pulumi:"minReplicaCount"` + // Seconds between checks of trigger metrics. Example: 30. + PollingInterval *int `pulumi:"pollingInterval"` + // KEDA scaler triggers driving this ScaledObject. + Triggers []KedaTriggerArgs `pulumi:"triggers"` } -type NamePatternArgs struct { - // Optional regex flags (e.g. 'i' for case-insensitive). - Flags *string `pulumi:"flags"` - // Regular expression pattern to match workload names. - Pattern *string `pulumi:"pattern"` -} - -// NamePatternArgsInput is an input type that accepts NamePatternArgsArgs and NamePatternArgsOutput values. -// You can construct a concrete instance of `NamePatternArgsInput` via: +// KedaScaledObjectArgsInput is an input type that accepts KedaScaledObjectArgsArgs and KedaScaledObjectArgsOutput values. +// You can construct a concrete instance of `KedaScaledObjectArgsInput` via: // -// NamePatternArgsArgs{...} -type NamePatternArgsInput interface { +// KedaScaledObjectArgsArgs{...} +type KedaScaledObjectArgsInput interface { pulumi.Input - ToNamePatternArgsOutput() NamePatternArgsOutput - ToNamePatternArgsOutputWithContext(context.Context) NamePatternArgsOutput -} - -type NamePatternArgsArgs struct { - // Optional regex flags (e.g. 'i' for case-insensitive). - Flags pulumi.StringPtrInput `pulumi:"flags"` - // Regular expression pattern to match workload names. - Pattern pulumi.StringPtrInput `pulumi:"pattern"` + ToKedaScaledObjectArgsOutput() KedaScaledObjectArgsOutput + ToKedaScaledObjectArgsOutputWithContext(context.Context) KedaScaledObjectArgsOutput +} + +type KedaScaledObjectArgsArgs struct { + // Advanced ScaledObject behavior configuration. + Advanced KedaAdvancedArgsPtrInput `pulumi:"advanced"` + // Seconds to wait after the last trigger reports active=false before scaling to minReplicaCount. Example: 300. + CooldownPeriod pulumi.IntPtrInput `pulumi:"cooldownPeriod"` + // Replica fallback configuration when KEDA metrics are unavailable. + Fallback KedaFallbackArgsPtrInput `pulumi:"fallback"` + // Replica count to scale to when idle. Must be less than minReplicaCount. Example: 0. + IdleReplicaCount pulumi.IntPtrInput `pulumi:"idleReplicaCount"` + // Cooldown period applied only during the initial scaling of the ScaledObject. Example: 0. + InitialCooldownPeriod pulumi.IntPtrInput `pulumi:"initialCooldownPeriod"` + // Maximum number of replicas. Example: 10. + MaxReplicaCount pulumi.IntPtrInput `pulumi:"maxReplicaCount"` + // Minimum number of replicas. Example: 0. + MinReplicaCount pulumi.IntPtrInput `pulumi:"minReplicaCount"` + // Seconds between checks of trigger metrics. Example: 30. + PollingInterval pulumi.IntPtrInput `pulumi:"pollingInterval"` + // KEDA scaler triggers driving this ScaledObject. + Triggers KedaTriggerArgsArrayInput `pulumi:"triggers"` } -func (NamePatternArgsArgs) ElementType() reflect.Type { - return reflect.TypeOf((*NamePatternArgs)(nil)).Elem() +func (KedaScaledObjectArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KedaScaledObjectArgs)(nil)).Elem() } -func (i NamePatternArgsArgs) ToNamePatternArgsOutput() NamePatternArgsOutput { - return i.ToNamePatternArgsOutputWithContext(context.Background()) +func (i KedaScaledObjectArgsArgs) ToKedaScaledObjectArgsOutput() KedaScaledObjectArgsOutput { + return i.ToKedaScaledObjectArgsOutputWithContext(context.Background()) } -func (i NamePatternArgsArgs) ToNamePatternArgsOutputWithContext(ctx context.Context) NamePatternArgsOutput { - return pulumi.ToOutputWithContext(ctx, i).(NamePatternArgsOutput) +func (i KedaScaledObjectArgsArgs) ToKedaScaledObjectArgsOutputWithContext(ctx context.Context) KedaScaledObjectArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(KedaScaledObjectArgsOutput) } -func (i NamePatternArgsArgs) ToNamePatternArgsPtrOutput() NamePatternArgsPtrOutput { - return i.ToNamePatternArgsPtrOutputWithContext(context.Background()) +func (i KedaScaledObjectArgsArgs) ToKedaScaledObjectArgsPtrOutput() KedaScaledObjectArgsPtrOutput { + return i.ToKedaScaledObjectArgsPtrOutputWithContext(context.Background()) } -func (i NamePatternArgsArgs) ToNamePatternArgsPtrOutputWithContext(ctx context.Context) NamePatternArgsPtrOutput { - return pulumi.ToOutputWithContext(ctx, i).(NamePatternArgsOutput).ToNamePatternArgsPtrOutputWithContext(ctx) +func (i KedaScaledObjectArgsArgs) ToKedaScaledObjectArgsPtrOutputWithContext(ctx context.Context) KedaScaledObjectArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KedaScaledObjectArgsOutput).ToKedaScaledObjectArgsPtrOutputWithContext(ctx) } -// NamePatternArgsPtrInput is an input type that accepts NamePatternArgsArgs, NamePatternArgsPtr and NamePatternArgsPtrOutput values. -// You can construct a concrete instance of `NamePatternArgsPtrInput` via: +// KedaScaledObjectArgsPtrInput is an input type that accepts KedaScaledObjectArgsArgs, KedaScaledObjectArgsPtr and KedaScaledObjectArgsPtrOutput values. +// You can construct a concrete instance of `KedaScaledObjectArgsPtrInput` via: // -// NamePatternArgsArgs{...} +// KedaScaledObjectArgsArgs{...} // // or: // // nil -type NamePatternArgsPtrInput interface { +type KedaScaledObjectArgsPtrInput interface { pulumi.Input - ToNamePatternArgsPtrOutput() NamePatternArgsPtrOutput - ToNamePatternArgsPtrOutputWithContext(context.Context) NamePatternArgsPtrOutput + ToKedaScaledObjectArgsPtrOutput() KedaScaledObjectArgsPtrOutput + ToKedaScaledObjectArgsPtrOutputWithContext(context.Context) KedaScaledObjectArgsPtrOutput } -type namePatternArgsPtrType NamePatternArgsArgs +type kedaScaledObjectArgsPtrType KedaScaledObjectArgsArgs -func NamePatternArgsPtr(v *NamePatternArgsArgs) NamePatternArgsPtrInput { - return (*namePatternArgsPtrType)(v) +func KedaScaledObjectArgsPtr(v *KedaScaledObjectArgsArgs) KedaScaledObjectArgsPtrInput { + return (*kedaScaledObjectArgsPtrType)(v) } -func (*namePatternArgsPtrType) ElementType() reflect.Type { - return reflect.TypeOf((**NamePatternArgs)(nil)).Elem() +func (*kedaScaledObjectArgsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KedaScaledObjectArgs)(nil)).Elem() } -func (i *namePatternArgsPtrType) ToNamePatternArgsPtrOutput() NamePatternArgsPtrOutput { - return i.ToNamePatternArgsPtrOutputWithContext(context.Background()) +func (i *kedaScaledObjectArgsPtrType) ToKedaScaledObjectArgsPtrOutput() KedaScaledObjectArgsPtrOutput { + return i.ToKedaScaledObjectArgsPtrOutputWithContext(context.Background()) } -func (i *namePatternArgsPtrType) ToNamePatternArgsPtrOutputWithContext(ctx context.Context) NamePatternArgsPtrOutput { - return pulumi.ToOutputWithContext(ctx, i).(NamePatternArgsPtrOutput) +func (i *kedaScaledObjectArgsPtrType) ToKedaScaledObjectArgsPtrOutputWithContext(ctx context.Context) KedaScaledObjectArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KedaScaledObjectArgsPtrOutput) } -type NamePatternArgsOutput struct{ *pulumi.OutputState } +type KedaScaledObjectArgsOutput struct{ *pulumi.OutputState } -func (NamePatternArgsOutput) ElementType() reflect.Type { - return reflect.TypeOf((*NamePatternArgs)(nil)).Elem() +func (KedaScaledObjectArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KedaScaledObjectArgs)(nil)).Elem() } -func (o NamePatternArgsOutput) ToNamePatternArgsOutput() NamePatternArgsOutput { +func (o KedaScaledObjectArgsOutput) ToKedaScaledObjectArgsOutput() KedaScaledObjectArgsOutput { return o } -func (o NamePatternArgsOutput) ToNamePatternArgsOutputWithContext(ctx context.Context) NamePatternArgsOutput { +func (o KedaScaledObjectArgsOutput) ToKedaScaledObjectArgsOutputWithContext(ctx context.Context) KedaScaledObjectArgsOutput { return o } -func (o NamePatternArgsOutput) ToNamePatternArgsPtrOutput() NamePatternArgsPtrOutput { - return o.ToNamePatternArgsPtrOutputWithContext(context.Background()) +func (o KedaScaledObjectArgsOutput) ToKedaScaledObjectArgsPtrOutput() KedaScaledObjectArgsPtrOutput { + return o.ToKedaScaledObjectArgsPtrOutputWithContext(context.Background()) } -func (o NamePatternArgsOutput) ToNamePatternArgsPtrOutputWithContext(ctx context.Context) NamePatternArgsPtrOutput { - return o.ApplyTWithContext(ctx, func(_ context.Context, v NamePatternArgs) *NamePatternArgs { +func (o KedaScaledObjectArgsOutput) ToKedaScaledObjectArgsPtrOutputWithContext(ctx context.Context) KedaScaledObjectArgsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KedaScaledObjectArgs) *KedaScaledObjectArgs { return &v - }).(NamePatternArgsPtrOutput) + }).(KedaScaledObjectArgsPtrOutput) } -// Optional regex flags (e.g. 'i' for case-insensitive). -func (o NamePatternArgsOutput) Flags() pulumi.StringPtrOutput { - return o.ApplyT(func(v NamePatternArgs) *string { return v.Flags }).(pulumi.StringPtrOutput) +// Advanced ScaledObject behavior configuration. +func (o KedaScaledObjectArgsOutput) Advanced() KedaAdvancedArgsPtrOutput { + return o.ApplyT(func(v KedaScaledObjectArgs) *KedaAdvancedArgs { return v.Advanced }).(KedaAdvancedArgsPtrOutput) } -// Regular expression pattern to match workload names. -func (o NamePatternArgsOutput) Pattern() pulumi.StringPtrOutput { - return o.ApplyT(func(v NamePatternArgs) *string { return v.Pattern }).(pulumi.StringPtrOutput) +// Seconds to wait after the last trigger reports active=false before scaling to minReplicaCount. Example: 300. +func (o KedaScaledObjectArgsOutput) CooldownPeriod() pulumi.IntPtrOutput { + return o.ApplyT(func(v KedaScaledObjectArgs) *int { return v.CooldownPeriod }).(pulumi.IntPtrOutput) } -type NamePatternArgsPtrOutput struct{ *pulumi.OutputState } +// Replica fallback configuration when KEDA metrics are unavailable. +func (o KedaScaledObjectArgsOutput) Fallback() KedaFallbackArgsPtrOutput { + return o.ApplyT(func(v KedaScaledObjectArgs) *KedaFallbackArgs { return v.Fallback }).(KedaFallbackArgsPtrOutput) +} -func (NamePatternArgsPtrOutput) ElementType() reflect.Type { - return reflect.TypeOf((**NamePatternArgs)(nil)).Elem() +// Replica count to scale to when idle. Must be less than minReplicaCount. Example: 0. +func (o KedaScaledObjectArgsOutput) IdleReplicaCount() pulumi.IntPtrOutput { + return o.ApplyT(func(v KedaScaledObjectArgs) *int { return v.IdleReplicaCount }).(pulumi.IntPtrOutput) } -func (o NamePatternArgsPtrOutput) ToNamePatternArgsPtrOutput() NamePatternArgsPtrOutput { +// Cooldown period applied only during the initial scaling of the ScaledObject. Example: 0. +func (o KedaScaledObjectArgsOutput) InitialCooldownPeriod() pulumi.IntPtrOutput { + return o.ApplyT(func(v KedaScaledObjectArgs) *int { return v.InitialCooldownPeriod }).(pulumi.IntPtrOutput) +} + +// Maximum number of replicas. Example: 10. +func (o KedaScaledObjectArgsOutput) MaxReplicaCount() pulumi.IntPtrOutput { + return o.ApplyT(func(v KedaScaledObjectArgs) *int { return v.MaxReplicaCount }).(pulumi.IntPtrOutput) +} + +// Minimum number of replicas. Example: 0. +func (o KedaScaledObjectArgsOutput) MinReplicaCount() pulumi.IntPtrOutput { + return o.ApplyT(func(v KedaScaledObjectArgs) *int { return v.MinReplicaCount }).(pulumi.IntPtrOutput) +} + +// Seconds between checks of trigger metrics. Example: 30. +func (o KedaScaledObjectArgsOutput) PollingInterval() pulumi.IntPtrOutput { + return o.ApplyT(func(v KedaScaledObjectArgs) *int { return v.PollingInterval }).(pulumi.IntPtrOutput) +} + +// KEDA scaler triggers driving this ScaledObject. +func (o KedaScaledObjectArgsOutput) Triggers() KedaTriggerArgsArrayOutput { + return o.ApplyT(func(v KedaScaledObjectArgs) []KedaTriggerArgs { return v.Triggers }).(KedaTriggerArgsArrayOutput) +} + +type KedaScaledObjectArgsPtrOutput struct{ *pulumi.OutputState } + +func (KedaScaledObjectArgsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KedaScaledObjectArgs)(nil)).Elem() +} + +func (o KedaScaledObjectArgsPtrOutput) ToKedaScaledObjectArgsPtrOutput() KedaScaledObjectArgsPtrOutput { return o } -func (o NamePatternArgsPtrOutput) ToNamePatternArgsPtrOutputWithContext(ctx context.Context) NamePatternArgsPtrOutput { +func (o KedaScaledObjectArgsPtrOutput) ToKedaScaledObjectArgsPtrOutputWithContext(ctx context.Context) KedaScaledObjectArgsPtrOutput { return o } -func (o NamePatternArgsPtrOutput) Elem() NamePatternArgsOutput { - return o.ApplyT(func(v *NamePatternArgs) NamePatternArgs { +func (o KedaScaledObjectArgsPtrOutput) Elem() KedaScaledObjectArgsOutput { + return o.ApplyT(func(v *KedaScaledObjectArgs) KedaScaledObjectArgs { if v != nil { return *v } - var ret NamePatternArgs + var ret KedaScaledObjectArgs return ret - }).(NamePatternArgsOutput) + }).(KedaScaledObjectArgsOutput) } -// Optional regex flags (e.g. 'i' for case-insensitive). -func (o NamePatternArgsPtrOutput) Flags() pulumi.StringPtrOutput { - return o.ApplyT(func(v *NamePatternArgs) *string { +// Advanced ScaledObject behavior configuration. +func (o KedaScaledObjectArgsPtrOutput) Advanced() KedaAdvancedArgsPtrOutput { + return o.ApplyT(func(v *KedaScaledObjectArgs) *KedaAdvancedArgs { if v == nil { return nil } - return v.Flags - }).(pulumi.StringPtrOutput) + return v.Advanced + }).(KedaAdvancedArgsPtrOutput) } -// Regular expression pattern to match workload names. -func (o NamePatternArgsPtrOutput) Pattern() pulumi.StringPtrOutput { - return o.ApplyT(func(v *NamePatternArgs) *string { +// Seconds to wait after the last trigger reports active=false before scaling to minReplicaCount. Example: 300. +func (o KedaScaledObjectArgsPtrOutput) CooldownPeriod() pulumi.IntPtrOutput { + return o.ApplyT(func(v *KedaScaledObjectArgs) *int { if v == nil { return nil } - return v.Pattern - }).(pulumi.StringPtrOutput) + return v.CooldownPeriod + }).(pulumi.IntPtrOutput) +} + +// Replica fallback configuration when KEDA metrics are unavailable. +func (o KedaScaledObjectArgsPtrOutput) Fallback() KedaFallbackArgsPtrOutput { + return o.ApplyT(func(v *KedaScaledObjectArgs) *KedaFallbackArgs { + if v == nil { + return nil + } + return v.Fallback + }).(KedaFallbackArgsPtrOutput) +} + +// Replica count to scale to when idle. Must be less than minReplicaCount. Example: 0. +func (o KedaScaledObjectArgsPtrOutput) IdleReplicaCount() pulumi.IntPtrOutput { + return o.ApplyT(func(v *KedaScaledObjectArgs) *int { + if v == nil { + return nil + } + return v.IdleReplicaCount + }).(pulumi.IntPtrOutput) +} + +// Cooldown period applied only during the initial scaling of the ScaledObject. Example: 0. +func (o KedaScaledObjectArgsPtrOutput) InitialCooldownPeriod() pulumi.IntPtrOutput { + return o.ApplyT(func(v *KedaScaledObjectArgs) *int { + if v == nil { + return nil + } + return v.InitialCooldownPeriod + }).(pulumi.IntPtrOutput) +} + +// Maximum number of replicas. Example: 10. +func (o KedaScaledObjectArgsPtrOutput) MaxReplicaCount() pulumi.IntPtrOutput { + return o.ApplyT(func(v *KedaScaledObjectArgs) *int { + if v == nil { + return nil + } + return v.MaxReplicaCount + }).(pulumi.IntPtrOutput) +} + +// Minimum number of replicas. Example: 0. +func (o KedaScaledObjectArgsPtrOutput) MinReplicaCount() pulumi.IntPtrOutput { + return o.ApplyT(func(v *KedaScaledObjectArgs) *int { + if v == nil { + return nil + } + return v.MinReplicaCount + }).(pulumi.IntPtrOutput) +} + +// Seconds between checks of trigger metrics. Example: 30. +func (o KedaScaledObjectArgsPtrOutput) PollingInterval() pulumi.IntPtrOutput { + return o.ApplyT(func(v *KedaScaledObjectArgs) *int { + if v == nil { + return nil + } + return v.PollingInterval + }).(pulumi.IntPtrOutput) +} + +// KEDA scaler triggers driving this ScaledObject. +func (o KedaScaledObjectArgsPtrOutput) Triggers() KedaTriggerArgsArrayOutput { + return o.ApplyT(func(v *KedaScaledObjectArgs) []KedaTriggerArgs { + if v == nil { + return nil + } + return v.Triggers + }).(KedaTriggerArgsArrayOutput) +} + +type KedaTriggerArgs struct { + // Reference to a TriggerAuthentication or ClusterTriggerAuthentication for this trigger. + AuthenticationRef *KedaAuthenticationRefArgs `pulumi:"authenticationRef"` + // Scaler-specific configuration key-value pairs. Example: {"serverAddress": "http://prometheus:9090", "query": "sum(rate(http_requests_total[2m]))"}. + Metadata map[string]string `pulumi:"metadata"` + // Metric target type. One of: 'Value', 'AverageValue', 'Utilization'. Example: 'AverageValue'. + MetricType *string `pulumi:"metricType"` + // Optional trigger name, used to disambiguate multiple triggers of the same type. Example: 'requests-per-second'. + Name *string `pulumi:"name"` + // KEDA scaler type. Example: 'prometheus'. + Type string `pulumi:"type"` + // Use KEDA's metric caching for this trigger. Example: false. + UseCachedMetrics *bool `pulumi:"useCachedMetrics"` +} + +// KedaTriggerArgsInput is an input type that accepts KedaTriggerArgsArgs and KedaTriggerArgsOutput values. +// You can construct a concrete instance of `KedaTriggerArgsInput` via: +// +// KedaTriggerArgsArgs{...} +type KedaTriggerArgsInput interface { + pulumi.Input + + ToKedaTriggerArgsOutput() KedaTriggerArgsOutput + ToKedaTriggerArgsOutputWithContext(context.Context) KedaTriggerArgsOutput +} + +type KedaTriggerArgsArgs struct { + // Reference to a TriggerAuthentication or ClusterTriggerAuthentication for this trigger. + AuthenticationRef KedaAuthenticationRefArgsPtrInput `pulumi:"authenticationRef"` + // Scaler-specific configuration key-value pairs. Example: {"serverAddress": "http://prometheus:9090", "query": "sum(rate(http_requests_total[2m]))"}. + Metadata pulumi.StringMapInput `pulumi:"metadata"` + // Metric target type. One of: 'Value', 'AverageValue', 'Utilization'. Example: 'AverageValue'. + MetricType pulumi.StringPtrInput `pulumi:"metricType"` + // Optional trigger name, used to disambiguate multiple triggers of the same type. Example: 'requests-per-second'. + Name pulumi.StringPtrInput `pulumi:"name"` + // KEDA scaler type. Example: 'prometheus'. + Type pulumi.StringInput `pulumi:"type"` + // Use KEDA's metric caching for this trigger. Example: false. + UseCachedMetrics pulumi.BoolPtrInput `pulumi:"useCachedMetrics"` +} + +func (KedaTriggerArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KedaTriggerArgs)(nil)).Elem() +} + +func (i KedaTriggerArgsArgs) ToKedaTriggerArgsOutput() KedaTriggerArgsOutput { + return i.ToKedaTriggerArgsOutputWithContext(context.Background()) +} + +func (i KedaTriggerArgsArgs) ToKedaTriggerArgsOutputWithContext(ctx context.Context) KedaTriggerArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(KedaTriggerArgsOutput) +} + +// KedaTriggerArgsArrayInput is an input type that accepts KedaTriggerArgsArray and KedaTriggerArgsArrayOutput values. +// You can construct a concrete instance of `KedaTriggerArgsArrayInput` via: +// +// KedaTriggerArgsArray{ KedaTriggerArgsArgs{...} } +type KedaTriggerArgsArrayInput interface { + pulumi.Input + + ToKedaTriggerArgsArrayOutput() KedaTriggerArgsArrayOutput + ToKedaTriggerArgsArrayOutputWithContext(context.Context) KedaTriggerArgsArrayOutput +} + +type KedaTriggerArgsArray []KedaTriggerArgsInput + +func (KedaTriggerArgsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]KedaTriggerArgs)(nil)).Elem() +} + +func (i KedaTriggerArgsArray) ToKedaTriggerArgsArrayOutput() KedaTriggerArgsArrayOutput { + return i.ToKedaTriggerArgsArrayOutputWithContext(context.Background()) +} + +func (i KedaTriggerArgsArray) ToKedaTriggerArgsArrayOutputWithContext(ctx context.Context) KedaTriggerArgsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(KedaTriggerArgsArrayOutput) +} + +type KedaTriggerArgsOutput struct{ *pulumi.OutputState } + +func (KedaTriggerArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KedaTriggerArgs)(nil)).Elem() +} + +func (o KedaTriggerArgsOutput) ToKedaTriggerArgsOutput() KedaTriggerArgsOutput { + return o +} + +func (o KedaTriggerArgsOutput) ToKedaTriggerArgsOutputWithContext(ctx context.Context) KedaTriggerArgsOutput { + return o +} + +// Reference to a TriggerAuthentication or ClusterTriggerAuthentication for this trigger. +func (o KedaTriggerArgsOutput) AuthenticationRef() KedaAuthenticationRefArgsPtrOutput { + return o.ApplyT(func(v KedaTriggerArgs) *KedaAuthenticationRefArgs { return v.AuthenticationRef }).(KedaAuthenticationRefArgsPtrOutput) +} + +// Scaler-specific configuration key-value pairs. Example: {"serverAddress": "http://prometheus:9090", "query": "sum(rate(http_requests_total[2m]))"}. +func (o KedaTriggerArgsOutput) Metadata() pulumi.StringMapOutput { + return o.ApplyT(func(v KedaTriggerArgs) map[string]string { return v.Metadata }).(pulumi.StringMapOutput) +} + +// Metric target type. One of: 'Value', 'AverageValue', 'Utilization'. Example: 'AverageValue'. +func (o KedaTriggerArgsOutput) MetricType() pulumi.StringPtrOutput { + return o.ApplyT(func(v KedaTriggerArgs) *string { return v.MetricType }).(pulumi.StringPtrOutput) +} + +// Optional trigger name, used to disambiguate multiple triggers of the same type. Example: 'requests-per-second'. +func (o KedaTriggerArgsOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v KedaTriggerArgs) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// KEDA scaler type. Example: 'prometheus'. +func (o KedaTriggerArgsOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v KedaTriggerArgs) string { return v.Type }).(pulumi.StringOutput) +} + +// Use KEDA's metric caching for this trigger. Example: false. +func (o KedaTriggerArgsOutput) UseCachedMetrics() pulumi.BoolPtrOutput { + return o.ApplyT(func(v KedaTriggerArgs) *bool { return v.UseCachedMetrics }).(pulumi.BoolPtrOutput) +} + +type KedaTriggerArgsArrayOutput struct{ *pulumi.OutputState } + +func (KedaTriggerArgsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]KedaTriggerArgs)(nil)).Elem() +} + +func (o KedaTriggerArgsArrayOutput) ToKedaTriggerArgsArrayOutput() KedaTriggerArgsArrayOutput { + return o +} + +func (o KedaTriggerArgsArrayOutput) ToKedaTriggerArgsArrayOutputWithContext(ctx context.Context) KedaTriggerArgsArrayOutput { + return o +} + +func (o KedaTriggerArgsArrayOutput) Index(i pulumi.IntInput) KedaTriggerArgsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) KedaTriggerArgs { + return vs[0].([]KedaTriggerArgs)[vs[1].(int)] + }).(KedaTriggerArgsOutput) +} + +type KubeletConfigurationArgs struct { + // DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. + ClusterDns []string `pulumi:"clusterDns"` + // Whether to enforce CPU CFS quota limits for containers. Example: true. + CpuCfsQuota *bool `pulumi:"cpuCfsQuota"` + // Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. + EvictionHard map[string]string `pulumi:"evictionHard"` + // Maximum pod termination grace period (seconds) during eviction. Example: 90. + EvictionMaxPodGracePeriod *int `pulumi:"evictionMaxPodGracePeriod"` + // Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. + EvictionSoft map[string]string `pulumi:"evictionSoft"` + // Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. + EvictionSoftGracePeriod map[string]string `pulumi:"evictionSoftGracePeriod"` + // Disk usage % that triggers image garbage collection. Example: 85. + ImageGcHighThresholdPercent *int `pulumi:"imageGcHighThresholdPercent"` + // Disk usage % at which image GC stops freeing space. Example: 70. + ImageGcLowThresholdPercent *int `pulumi:"imageGcLowThresholdPercent"` + // Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. + KubeReserved map[string]string `pulumi:"kubeReserved"` + // Maximum number of pods allowed per node. Example: 110. + MaxPods *int `pulumi:"maxPods"` + // Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. + PodsPerCore *int `pulumi:"podsPerCore"` + // Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. + SystemReserved map[string]string `pulumi:"systemReserved"` +} + +// KubeletConfigurationArgsInput is an input type that accepts KubeletConfigurationArgsArgs and KubeletConfigurationArgsOutput values. +// You can construct a concrete instance of `KubeletConfigurationArgsInput` via: +// +// KubeletConfigurationArgsArgs{...} +type KubeletConfigurationArgsInput interface { + pulumi.Input + + ToKubeletConfigurationArgsOutput() KubeletConfigurationArgsOutput + ToKubeletConfigurationArgsOutputWithContext(context.Context) KubeletConfigurationArgsOutput +} + +type KubeletConfigurationArgsArgs struct { + // DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. + ClusterDns pulumi.StringArrayInput `pulumi:"clusterDns"` + // Whether to enforce CPU CFS quota limits for containers. Example: true. + CpuCfsQuota pulumi.BoolPtrInput `pulumi:"cpuCfsQuota"` + // Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. + EvictionHard pulumi.StringMapInput `pulumi:"evictionHard"` + // Maximum pod termination grace period (seconds) during eviction. Example: 90. + EvictionMaxPodGracePeriod pulumi.IntPtrInput `pulumi:"evictionMaxPodGracePeriod"` + // Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. + EvictionSoft pulumi.StringMapInput `pulumi:"evictionSoft"` + // Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. + EvictionSoftGracePeriod pulumi.StringMapInput `pulumi:"evictionSoftGracePeriod"` + // Disk usage % that triggers image garbage collection. Example: 85. + ImageGcHighThresholdPercent pulumi.IntPtrInput `pulumi:"imageGcHighThresholdPercent"` + // Disk usage % at which image GC stops freeing space. Example: 70. + ImageGcLowThresholdPercent pulumi.IntPtrInput `pulumi:"imageGcLowThresholdPercent"` + // Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. + KubeReserved pulumi.StringMapInput `pulumi:"kubeReserved"` + // Maximum number of pods allowed per node. Example: 110. + MaxPods pulumi.IntPtrInput `pulumi:"maxPods"` + // Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. + PodsPerCore pulumi.IntPtrInput `pulumi:"podsPerCore"` + // Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. + SystemReserved pulumi.StringMapInput `pulumi:"systemReserved"` +} + +func (KubeletConfigurationArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KubeletConfigurationArgs)(nil)).Elem() +} + +func (i KubeletConfigurationArgsArgs) ToKubeletConfigurationArgsOutput() KubeletConfigurationArgsOutput { + return i.ToKubeletConfigurationArgsOutputWithContext(context.Background()) +} + +func (i KubeletConfigurationArgsArgs) ToKubeletConfigurationArgsOutputWithContext(ctx context.Context) KubeletConfigurationArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(KubeletConfigurationArgsOutput) +} + +func (i KubeletConfigurationArgsArgs) ToKubeletConfigurationArgsPtrOutput() KubeletConfigurationArgsPtrOutput { + return i.ToKubeletConfigurationArgsPtrOutputWithContext(context.Background()) +} + +func (i KubeletConfigurationArgsArgs) ToKubeletConfigurationArgsPtrOutputWithContext(ctx context.Context) KubeletConfigurationArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KubeletConfigurationArgsOutput).ToKubeletConfigurationArgsPtrOutputWithContext(ctx) +} + +// KubeletConfigurationArgsPtrInput is an input type that accepts KubeletConfigurationArgsArgs, KubeletConfigurationArgsPtr and KubeletConfigurationArgsPtrOutput values. +// You can construct a concrete instance of `KubeletConfigurationArgsPtrInput` via: +// +// KubeletConfigurationArgsArgs{...} +// +// or: +// +// nil +type KubeletConfigurationArgsPtrInput interface { + pulumi.Input + + ToKubeletConfigurationArgsPtrOutput() KubeletConfigurationArgsPtrOutput + ToKubeletConfigurationArgsPtrOutputWithContext(context.Context) KubeletConfigurationArgsPtrOutput +} + +type kubeletConfigurationArgsPtrType KubeletConfigurationArgsArgs + +func KubeletConfigurationArgsPtr(v *KubeletConfigurationArgsArgs) KubeletConfigurationArgsPtrInput { + return (*kubeletConfigurationArgsPtrType)(v) +} + +func (*kubeletConfigurationArgsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KubeletConfigurationArgs)(nil)).Elem() +} + +func (i *kubeletConfigurationArgsPtrType) ToKubeletConfigurationArgsPtrOutput() KubeletConfigurationArgsPtrOutput { + return i.ToKubeletConfigurationArgsPtrOutputWithContext(context.Background()) +} + +func (i *kubeletConfigurationArgsPtrType) ToKubeletConfigurationArgsPtrOutputWithContext(ctx context.Context) KubeletConfigurationArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KubeletConfigurationArgsPtrOutput) +} + +type KubeletConfigurationArgsOutput struct{ *pulumi.OutputState } + +func (KubeletConfigurationArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KubeletConfigurationArgs)(nil)).Elem() +} + +func (o KubeletConfigurationArgsOutput) ToKubeletConfigurationArgsOutput() KubeletConfigurationArgsOutput { + return o +} + +func (o KubeletConfigurationArgsOutput) ToKubeletConfigurationArgsOutputWithContext(ctx context.Context) KubeletConfigurationArgsOutput { + return o +} + +func (o KubeletConfigurationArgsOutput) ToKubeletConfigurationArgsPtrOutput() KubeletConfigurationArgsPtrOutput { + return o.ToKubeletConfigurationArgsPtrOutputWithContext(context.Background()) +} + +func (o KubeletConfigurationArgsOutput) ToKubeletConfigurationArgsPtrOutputWithContext(ctx context.Context) KubeletConfigurationArgsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KubeletConfigurationArgs) *KubeletConfigurationArgs { + return &v + }).(KubeletConfigurationArgsPtrOutput) +} + +// DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. +func (o KubeletConfigurationArgsOutput) ClusterDns() pulumi.StringArrayOutput { + return o.ApplyT(func(v KubeletConfigurationArgs) []string { return v.ClusterDns }).(pulumi.StringArrayOutput) +} + +// Whether to enforce CPU CFS quota limits for containers. Example: true. +func (o KubeletConfigurationArgsOutput) CpuCfsQuota() pulumi.BoolPtrOutput { + return o.ApplyT(func(v KubeletConfigurationArgs) *bool { return v.CpuCfsQuota }).(pulumi.BoolPtrOutput) +} + +// Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. +func (o KubeletConfigurationArgsOutput) EvictionHard() pulumi.StringMapOutput { + return o.ApplyT(func(v KubeletConfigurationArgs) map[string]string { return v.EvictionHard }).(pulumi.StringMapOutput) +} + +// Maximum pod termination grace period (seconds) during eviction. Example: 90. +func (o KubeletConfigurationArgsOutput) EvictionMaxPodGracePeriod() pulumi.IntPtrOutput { + return o.ApplyT(func(v KubeletConfigurationArgs) *int { return v.EvictionMaxPodGracePeriod }).(pulumi.IntPtrOutput) +} + +// Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. +func (o KubeletConfigurationArgsOutput) EvictionSoft() pulumi.StringMapOutput { + return o.ApplyT(func(v KubeletConfigurationArgs) map[string]string { return v.EvictionSoft }).(pulumi.StringMapOutput) +} + +// Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. +func (o KubeletConfigurationArgsOutput) EvictionSoftGracePeriod() pulumi.StringMapOutput { + return o.ApplyT(func(v KubeletConfigurationArgs) map[string]string { return v.EvictionSoftGracePeriod }).(pulumi.StringMapOutput) +} + +// Disk usage % that triggers image garbage collection. Example: 85. +func (o KubeletConfigurationArgsOutput) ImageGcHighThresholdPercent() pulumi.IntPtrOutput { + return o.ApplyT(func(v KubeletConfigurationArgs) *int { return v.ImageGcHighThresholdPercent }).(pulumi.IntPtrOutput) +} + +// Disk usage % at which image GC stops freeing space. Example: 70. +func (o KubeletConfigurationArgsOutput) ImageGcLowThresholdPercent() pulumi.IntPtrOutput { + return o.ApplyT(func(v KubeletConfigurationArgs) *int { return v.ImageGcLowThresholdPercent }).(pulumi.IntPtrOutput) +} + +// Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. +func (o KubeletConfigurationArgsOutput) KubeReserved() pulumi.StringMapOutput { + return o.ApplyT(func(v KubeletConfigurationArgs) map[string]string { return v.KubeReserved }).(pulumi.StringMapOutput) +} + +// Maximum number of pods allowed per node. Example: 110. +func (o KubeletConfigurationArgsOutput) MaxPods() pulumi.IntPtrOutput { + return o.ApplyT(func(v KubeletConfigurationArgs) *int { return v.MaxPods }).(pulumi.IntPtrOutput) +} + +// Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. +func (o KubeletConfigurationArgsOutput) PodsPerCore() pulumi.IntPtrOutput { + return o.ApplyT(func(v KubeletConfigurationArgs) *int { return v.PodsPerCore }).(pulumi.IntPtrOutput) +} + +// Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. +func (o KubeletConfigurationArgsOutput) SystemReserved() pulumi.StringMapOutput { + return o.ApplyT(func(v KubeletConfigurationArgs) map[string]string { return v.SystemReserved }).(pulumi.StringMapOutput) +} + +type KubeletConfigurationArgsPtrOutput struct{ *pulumi.OutputState } + +func (KubeletConfigurationArgsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KubeletConfigurationArgs)(nil)).Elem() +} + +func (o KubeletConfigurationArgsPtrOutput) ToKubeletConfigurationArgsPtrOutput() KubeletConfigurationArgsPtrOutput { + return o +} + +func (o KubeletConfigurationArgsPtrOutput) ToKubeletConfigurationArgsPtrOutputWithContext(ctx context.Context) KubeletConfigurationArgsPtrOutput { + return o +} + +func (o KubeletConfigurationArgsPtrOutput) Elem() KubeletConfigurationArgsOutput { + return o.ApplyT(func(v *KubeletConfigurationArgs) KubeletConfigurationArgs { + if v != nil { + return *v + } + var ret KubeletConfigurationArgs + return ret + }).(KubeletConfigurationArgsOutput) +} + +// DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. +func (o KubeletConfigurationArgsPtrOutput) ClusterDns() pulumi.StringArrayOutput { + return o.ApplyT(func(v *KubeletConfigurationArgs) []string { + if v == nil { + return nil + } + return v.ClusterDns + }).(pulumi.StringArrayOutput) +} + +// Whether to enforce CPU CFS quota limits for containers. Example: true. +func (o KubeletConfigurationArgsPtrOutput) CpuCfsQuota() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *KubeletConfigurationArgs) *bool { + if v == nil { + return nil + } + return v.CpuCfsQuota + }).(pulumi.BoolPtrOutput) +} + +// Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. +func (o KubeletConfigurationArgsPtrOutput) EvictionHard() pulumi.StringMapOutput { + return o.ApplyT(func(v *KubeletConfigurationArgs) map[string]string { + if v == nil { + return nil + } + return v.EvictionHard + }).(pulumi.StringMapOutput) +} + +// Maximum pod termination grace period (seconds) during eviction. Example: 90. +func (o KubeletConfigurationArgsPtrOutput) EvictionMaxPodGracePeriod() pulumi.IntPtrOutput { + return o.ApplyT(func(v *KubeletConfigurationArgs) *int { + if v == nil { + return nil + } + return v.EvictionMaxPodGracePeriod + }).(pulumi.IntPtrOutput) +} + +// Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. +func (o KubeletConfigurationArgsPtrOutput) EvictionSoft() pulumi.StringMapOutput { + return o.ApplyT(func(v *KubeletConfigurationArgs) map[string]string { + if v == nil { + return nil + } + return v.EvictionSoft + }).(pulumi.StringMapOutput) +} + +// Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. +func (o KubeletConfigurationArgsPtrOutput) EvictionSoftGracePeriod() pulumi.StringMapOutput { + return o.ApplyT(func(v *KubeletConfigurationArgs) map[string]string { + if v == nil { + return nil + } + return v.EvictionSoftGracePeriod + }).(pulumi.StringMapOutput) +} + +// Disk usage % that triggers image garbage collection. Example: 85. +func (o KubeletConfigurationArgsPtrOutput) ImageGcHighThresholdPercent() pulumi.IntPtrOutput { + return o.ApplyT(func(v *KubeletConfigurationArgs) *int { + if v == nil { + return nil + } + return v.ImageGcHighThresholdPercent + }).(pulumi.IntPtrOutput) +} + +// Disk usage % at which image GC stops freeing space. Example: 70. +func (o KubeletConfigurationArgsPtrOutput) ImageGcLowThresholdPercent() pulumi.IntPtrOutput { + return o.ApplyT(func(v *KubeletConfigurationArgs) *int { + if v == nil { + return nil + } + return v.ImageGcLowThresholdPercent + }).(pulumi.IntPtrOutput) +} + +// Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. +func (o KubeletConfigurationArgsPtrOutput) KubeReserved() pulumi.StringMapOutput { + return o.ApplyT(func(v *KubeletConfigurationArgs) map[string]string { + if v == nil { + return nil + } + return v.KubeReserved + }).(pulumi.StringMapOutput) +} + +// Maximum number of pods allowed per node. Example: 110. +func (o KubeletConfigurationArgsPtrOutput) MaxPods() pulumi.IntPtrOutput { + return o.ApplyT(func(v *KubeletConfigurationArgs) *int { + if v == nil { + return nil + } + return v.MaxPods + }).(pulumi.IntPtrOutput) +} + +// Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. +func (o KubeletConfigurationArgsPtrOutput) PodsPerCore() pulumi.IntPtrOutput { + return o.ApplyT(func(v *KubeletConfigurationArgs) *int { + if v == nil { + return nil + } + return v.PodsPerCore + }).(pulumi.IntPtrOutput) +} + +// Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. +func (o KubeletConfigurationArgsPtrOutput) SystemReserved() pulumi.StringMapOutput { + return o.ApplyT(func(v *KubeletConfigurationArgs) map[string]string { + if v == nil { + return nil + } + return v.SystemReserved + }).(pulumi.StringMapOutput) +} + +type LabelSelectorArgs struct { + // List of label selector requirements joined by AND. + MatchExpressions []LabelSelectorRequirementArgs `pulumi:"matchExpressions"` + // Map of label key-value pairs that must all match exactly. + MatchLabels map[string]string `pulumi:"matchLabels"` +} + +// LabelSelectorArgsInput is an input type that accepts LabelSelectorArgsArgs and LabelSelectorArgsOutput values. +// You can construct a concrete instance of `LabelSelectorArgsInput` via: +// +// LabelSelectorArgsArgs{...} +type LabelSelectorArgsInput interface { + pulumi.Input + + ToLabelSelectorArgsOutput() LabelSelectorArgsOutput + ToLabelSelectorArgsOutputWithContext(context.Context) LabelSelectorArgsOutput +} + +type LabelSelectorArgsArgs struct { + // List of label selector requirements joined by AND. + MatchExpressions LabelSelectorRequirementArgsArrayInput `pulumi:"matchExpressions"` + // Map of label key-value pairs that must all match exactly. + MatchLabels pulumi.StringMapInput `pulumi:"matchLabels"` +} + +func (LabelSelectorArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LabelSelectorArgs)(nil)).Elem() +} + +func (i LabelSelectorArgsArgs) ToLabelSelectorArgsOutput() LabelSelectorArgsOutput { + return i.ToLabelSelectorArgsOutputWithContext(context.Background()) +} + +func (i LabelSelectorArgsArgs) ToLabelSelectorArgsOutputWithContext(ctx context.Context) LabelSelectorArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorArgsOutput) +} + +func (i LabelSelectorArgsArgs) ToLabelSelectorArgsPtrOutput() LabelSelectorArgsPtrOutput { + return i.ToLabelSelectorArgsPtrOutputWithContext(context.Background()) +} + +func (i LabelSelectorArgsArgs) ToLabelSelectorArgsPtrOutputWithContext(ctx context.Context) LabelSelectorArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorArgsOutput).ToLabelSelectorArgsPtrOutputWithContext(ctx) +} + +// LabelSelectorArgsPtrInput is an input type that accepts LabelSelectorArgsArgs, LabelSelectorArgsPtr and LabelSelectorArgsPtrOutput values. +// You can construct a concrete instance of `LabelSelectorArgsPtrInput` via: +// +// LabelSelectorArgsArgs{...} +// +// or: +// +// nil +type LabelSelectorArgsPtrInput interface { + pulumi.Input + + ToLabelSelectorArgsPtrOutput() LabelSelectorArgsPtrOutput + ToLabelSelectorArgsPtrOutputWithContext(context.Context) LabelSelectorArgsPtrOutput +} + +type labelSelectorArgsPtrType LabelSelectorArgsArgs + +func LabelSelectorArgsPtr(v *LabelSelectorArgsArgs) LabelSelectorArgsPtrInput { + return (*labelSelectorArgsPtrType)(v) +} + +func (*labelSelectorArgsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**LabelSelectorArgs)(nil)).Elem() +} + +func (i *labelSelectorArgsPtrType) ToLabelSelectorArgsPtrOutput() LabelSelectorArgsPtrOutput { + return i.ToLabelSelectorArgsPtrOutputWithContext(context.Background()) +} + +func (i *labelSelectorArgsPtrType) ToLabelSelectorArgsPtrOutputWithContext(ctx context.Context) LabelSelectorArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorArgsPtrOutput) +} + +type LabelSelectorArgsOutput struct{ *pulumi.OutputState } + +func (LabelSelectorArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LabelSelectorArgs)(nil)).Elem() +} + +func (o LabelSelectorArgsOutput) ToLabelSelectorArgsOutput() LabelSelectorArgsOutput { + return o +} + +func (o LabelSelectorArgsOutput) ToLabelSelectorArgsOutputWithContext(ctx context.Context) LabelSelectorArgsOutput { + return o +} + +func (o LabelSelectorArgsOutput) ToLabelSelectorArgsPtrOutput() LabelSelectorArgsPtrOutput { + return o.ToLabelSelectorArgsPtrOutputWithContext(context.Background()) +} + +func (o LabelSelectorArgsOutput) ToLabelSelectorArgsPtrOutputWithContext(ctx context.Context) LabelSelectorArgsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v LabelSelectorArgs) *LabelSelectorArgs { + return &v + }).(LabelSelectorArgsPtrOutput) +} + +// List of label selector requirements joined by AND. +func (o LabelSelectorArgsOutput) MatchExpressions() LabelSelectorRequirementArgsArrayOutput { + return o.ApplyT(func(v LabelSelectorArgs) []LabelSelectorRequirementArgs { return v.MatchExpressions }).(LabelSelectorRequirementArgsArrayOutput) +} + +// Map of label key-value pairs that must all match exactly. +func (o LabelSelectorArgsOutput) MatchLabels() pulumi.StringMapOutput { + return o.ApplyT(func(v LabelSelectorArgs) map[string]string { return v.MatchLabels }).(pulumi.StringMapOutput) +} + +type LabelSelectorArgsPtrOutput struct{ *pulumi.OutputState } + +func (LabelSelectorArgsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**LabelSelectorArgs)(nil)).Elem() +} + +func (o LabelSelectorArgsPtrOutput) ToLabelSelectorArgsPtrOutput() LabelSelectorArgsPtrOutput { + return o +} + +func (o LabelSelectorArgsPtrOutput) ToLabelSelectorArgsPtrOutputWithContext(ctx context.Context) LabelSelectorArgsPtrOutput { + return o +} + +func (o LabelSelectorArgsPtrOutput) Elem() LabelSelectorArgsOutput { + return o.ApplyT(func(v *LabelSelectorArgs) LabelSelectorArgs { + if v != nil { + return *v + } + var ret LabelSelectorArgs + return ret + }).(LabelSelectorArgsOutput) +} + +// List of label selector requirements joined by AND. +func (o LabelSelectorArgsPtrOutput) MatchExpressions() LabelSelectorRequirementArgsArrayOutput { + return o.ApplyT(func(v *LabelSelectorArgs) []LabelSelectorRequirementArgs { + if v == nil { + return nil + } + return v.MatchExpressions + }).(LabelSelectorRequirementArgsArrayOutput) +} + +// Map of label key-value pairs that must all match exactly. +func (o LabelSelectorArgsPtrOutput) MatchLabels() pulumi.StringMapOutput { + return o.ApplyT(func(v *LabelSelectorArgs) map[string]string { + if v == nil { + return nil + } + return v.MatchLabels + }).(pulumi.StringMapOutput) +} + +type LabelSelectorRequirementArgs struct { + // The label key that the selector applies to. + Key *string `pulumi:"key"` + // Operator relating the key and values. One of: 'In', 'NotIn', 'Exists', 'DoesNotExist'. + Operator *string `pulumi:"operator"` + // Array of string values. Required for 'In' and 'NotIn' operators. + Values []string `pulumi:"values"` +} + +// LabelSelectorRequirementArgsInput is an input type that accepts LabelSelectorRequirementArgsArgs and LabelSelectorRequirementArgsOutput values. +// You can construct a concrete instance of `LabelSelectorRequirementArgsInput` via: +// +// LabelSelectorRequirementArgsArgs{...} +type LabelSelectorRequirementArgsInput interface { + pulumi.Input + + ToLabelSelectorRequirementArgsOutput() LabelSelectorRequirementArgsOutput + ToLabelSelectorRequirementArgsOutputWithContext(context.Context) LabelSelectorRequirementArgsOutput +} + +type LabelSelectorRequirementArgsArgs struct { + // The label key that the selector applies to. + Key pulumi.StringPtrInput `pulumi:"key"` + // Operator relating the key and values. One of: 'In', 'NotIn', 'Exists', 'DoesNotExist'. + Operator pulumi.StringPtrInput `pulumi:"operator"` + // Array of string values. Required for 'In' and 'NotIn' operators. + Values pulumi.StringArrayInput `pulumi:"values"` +} + +func (LabelSelectorRequirementArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LabelSelectorRequirementArgs)(nil)).Elem() +} + +func (i LabelSelectorRequirementArgsArgs) ToLabelSelectorRequirementArgsOutput() LabelSelectorRequirementArgsOutput { + return i.ToLabelSelectorRequirementArgsOutputWithContext(context.Background()) +} + +func (i LabelSelectorRequirementArgsArgs) ToLabelSelectorRequirementArgsOutputWithContext(ctx context.Context) LabelSelectorRequirementArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorRequirementArgsOutput) +} + +// LabelSelectorRequirementArgsArrayInput is an input type that accepts LabelSelectorRequirementArgsArray and LabelSelectorRequirementArgsArrayOutput values. +// You can construct a concrete instance of `LabelSelectorRequirementArgsArrayInput` via: +// +// LabelSelectorRequirementArgsArray{ LabelSelectorRequirementArgsArgs{...} } +type LabelSelectorRequirementArgsArrayInput interface { + pulumi.Input + + ToLabelSelectorRequirementArgsArrayOutput() LabelSelectorRequirementArgsArrayOutput + ToLabelSelectorRequirementArgsArrayOutputWithContext(context.Context) LabelSelectorRequirementArgsArrayOutput +} + +type LabelSelectorRequirementArgsArray []LabelSelectorRequirementArgsInput + +func (LabelSelectorRequirementArgsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]LabelSelectorRequirementArgs)(nil)).Elem() +} + +func (i LabelSelectorRequirementArgsArray) ToLabelSelectorRequirementArgsArrayOutput() LabelSelectorRequirementArgsArrayOutput { + return i.ToLabelSelectorRequirementArgsArrayOutputWithContext(context.Background()) +} + +func (i LabelSelectorRequirementArgsArray) ToLabelSelectorRequirementArgsArrayOutputWithContext(ctx context.Context) LabelSelectorRequirementArgsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(LabelSelectorRequirementArgsArrayOutput) +} + +type LabelSelectorRequirementArgsOutput struct{ *pulumi.OutputState } + +func (LabelSelectorRequirementArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LabelSelectorRequirementArgs)(nil)).Elem() +} + +func (o LabelSelectorRequirementArgsOutput) ToLabelSelectorRequirementArgsOutput() LabelSelectorRequirementArgsOutput { + return o +} + +func (o LabelSelectorRequirementArgsOutput) ToLabelSelectorRequirementArgsOutputWithContext(ctx context.Context) LabelSelectorRequirementArgsOutput { + return o +} + +// The label key that the selector applies to. +func (o LabelSelectorRequirementArgsOutput) Key() pulumi.StringPtrOutput { + return o.ApplyT(func(v LabelSelectorRequirementArgs) *string { return v.Key }).(pulumi.StringPtrOutput) +} + +// Operator relating the key and values. One of: 'In', 'NotIn', 'Exists', 'DoesNotExist'. +func (o LabelSelectorRequirementArgsOutput) Operator() pulumi.StringPtrOutput { + return o.ApplyT(func(v LabelSelectorRequirementArgs) *string { return v.Operator }).(pulumi.StringPtrOutput) +} + +// Array of string values. Required for 'In' and 'NotIn' operators. +func (o LabelSelectorRequirementArgsOutput) Values() pulumi.StringArrayOutput { + return o.ApplyT(func(v LabelSelectorRequirementArgs) []string { return v.Values }).(pulumi.StringArrayOutput) +} + +type LabelSelectorRequirementArgsArrayOutput struct{ *pulumi.OutputState } + +func (LabelSelectorRequirementArgsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]LabelSelectorRequirementArgs)(nil)).Elem() +} + +func (o LabelSelectorRequirementArgsArrayOutput) ToLabelSelectorRequirementArgsArrayOutput() LabelSelectorRequirementArgsArrayOutput { + return o +} + +func (o LabelSelectorRequirementArgsArrayOutput) ToLabelSelectorRequirementArgsArrayOutputWithContext(ctx context.Context) LabelSelectorRequirementArgsArrayOutput { + return o +} + +func (o LabelSelectorRequirementArgsArrayOutput) Index(i pulumi.IntInput) LabelSelectorRequirementArgsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) LabelSelectorRequirementArgs { + return vs[0].([]LabelSelectorRequirementArgs)[vs[1].(int)] + }).(LabelSelectorRequirementArgsOutput) +} + +type MetadataOptionsArgs struct { + // Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. + HttpEndpoint *string `pulumi:"httpEndpoint"` + // Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. + HttpProtocolIpv6 *string `pulumi:"httpProtocolIpv6"` + // HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. + HttpPutResponseHopLimit *int `pulumi:"httpPutResponseHopLimit"` + // Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. + HttpTokens *string `pulumi:"httpTokens"` +} + +// MetadataOptionsArgsInput is an input type that accepts MetadataOptionsArgsArgs and MetadataOptionsArgsOutput values. +// You can construct a concrete instance of `MetadataOptionsArgsInput` via: +// +// MetadataOptionsArgsArgs{...} +type MetadataOptionsArgsInput interface { + pulumi.Input + + ToMetadataOptionsArgsOutput() MetadataOptionsArgsOutput + ToMetadataOptionsArgsOutputWithContext(context.Context) MetadataOptionsArgsOutput +} + +type MetadataOptionsArgsArgs struct { + // Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. + HttpEndpoint pulumi.StringPtrInput `pulumi:"httpEndpoint"` + // Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. + HttpProtocolIpv6 pulumi.StringPtrInput `pulumi:"httpProtocolIpv6"` + // HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. + HttpPutResponseHopLimit pulumi.IntPtrInput `pulumi:"httpPutResponseHopLimit"` + // Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. + HttpTokens pulumi.StringPtrInput `pulumi:"httpTokens"` +} + +func (MetadataOptionsArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*MetadataOptionsArgs)(nil)).Elem() +} + +func (i MetadataOptionsArgsArgs) ToMetadataOptionsArgsOutput() MetadataOptionsArgsOutput { + return i.ToMetadataOptionsArgsOutputWithContext(context.Background()) +} + +func (i MetadataOptionsArgsArgs) ToMetadataOptionsArgsOutputWithContext(ctx context.Context) MetadataOptionsArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(MetadataOptionsArgsOutput) +} + +func (i MetadataOptionsArgsArgs) ToMetadataOptionsArgsPtrOutput() MetadataOptionsArgsPtrOutput { + return i.ToMetadataOptionsArgsPtrOutputWithContext(context.Background()) +} + +func (i MetadataOptionsArgsArgs) ToMetadataOptionsArgsPtrOutputWithContext(ctx context.Context) MetadataOptionsArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(MetadataOptionsArgsOutput).ToMetadataOptionsArgsPtrOutputWithContext(ctx) +} + +// MetadataOptionsArgsPtrInput is an input type that accepts MetadataOptionsArgsArgs, MetadataOptionsArgsPtr and MetadataOptionsArgsPtrOutput values. +// You can construct a concrete instance of `MetadataOptionsArgsPtrInput` via: +// +// MetadataOptionsArgsArgs{...} +// +// or: +// +// nil +type MetadataOptionsArgsPtrInput interface { + pulumi.Input + + ToMetadataOptionsArgsPtrOutput() MetadataOptionsArgsPtrOutput + ToMetadataOptionsArgsPtrOutputWithContext(context.Context) MetadataOptionsArgsPtrOutput +} + +type metadataOptionsArgsPtrType MetadataOptionsArgsArgs + +func MetadataOptionsArgsPtr(v *MetadataOptionsArgsArgs) MetadataOptionsArgsPtrInput { + return (*metadataOptionsArgsPtrType)(v) +} + +func (*metadataOptionsArgsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**MetadataOptionsArgs)(nil)).Elem() +} + +func (i *metadataOptionsArgsPtrType) ToMetadataOptionsArgsPtrOutput() MetadataOptionsArgsPtrOutput { + return i.ToMetadataOptionsArgsPtrOutputWithContext(context.Background()) +} + +func (i *metadataOptionsArgsPtrType) ToMetadataOptionsArgsPtrOutputWithContext(ctx context.Context) MetadataOptionsArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(MetadataOptionsArgsPtrOutput) +} + +type MetadataOptionsArgsOutput struct{ *pulumi.OutputState } + +func (MetadataOptionsArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*MetadataOptionsArgs)(nil)).Elem() +} + +func (o MetadataOptionsArgsOutput) ToMetadataOptionsArgsOutput() MetadataOptionsArgsOutput { + return o +} + +func (o MetadataOptionsArgsOutput) ToMetadataOptionsArgsOutputWithContext(ctx context.Context) MetadataOptionsArgsOutput { + return o +} + +func (o MetadataOptionsArgsOutput) ToMetadataOptionsArgsPtrOutput() MetadataOptionsArgsPtrOutput { + return o.ToMetadataOptionsArgsPtrOutputWithContext(context.Background()) +} + +func (o MetadataOptionsArgsOutput) ToMetadataOptionsArgsPtrOutputWithContext(ctx context.Context) MetadataOptionsArgsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v MetadataOptionsArgs) *MetadataOptionsArgs { + return &v + }).(MetadataOptionsArgsPtrOutput) +} + +// Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. +func (o MetadataOptionsArgsOutput) HttpEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v MetadataOptionsArgs) *string { return v.HttpEndpoint }).(pulumi.StringPtrOutput) +} + +// Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. +func (o MetadataOptionsArgsOutput) HttpProtocolIpv6() pulumi.StringPtrOutput { + return o.ApplyT(func(v MetadataOptionsArgs) *string { return v.HttpProtocolIpv6 }).(pulumi.StringPtrOutput) +} + +// HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. +func (o MetadataOptionsArgsOutput) HttpPutResponseHopLimit() pulumi.IntPtrOutput { + return o.ApplyT(func(v MetadataOptionsArgs) *int { return v.HttpPutResponseHopLimit }).(pulumi.IntPtrOutput) +} + +// Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. +func (o MetadataOptionsArgsOutput) HttpTokens() pulumi.StringPtrOutput { + return o.ApplyT(func(v MetadataOptionsArgs) *string { return v.HttpTokens }).(pulumi.StringPtrOutput) +} + +type MetadataOptionsArgsPtrOutput struct{ *pulumi.OutputState } + +func (MetadataOptionsArgsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**MetadataOptionsArgs)(nil)).Elem() +} + +func (o MetadataOptionsArgsPtrOutput) ToMetadataOptionsArgsPtrOutput() MetadataOptionsArgsPtrOutput { + return o +} + +func (o MetadataOptionsArgsPtrOutput) ToMetadataOptionsArgsPtrOutputWithContext(ctx context.Context) MetadataOptionsArgsPtrOutput { + return o +} + +func (o MetadataOptionsArgsPtrOutput) Elem() MetadataOptionsArgsOutput { + return o.ApplyT(func(v *MetadataOptionsArgs) MetadataOptionsArgs { + if v != nil { + return *v + } + var ret MetadataOptionsArgs + return ret + }).(MetadataOptionsArgsOutput) +} + +// Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. +func (o MetadataOptionsArgsPtrOutput) HttpEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *MetadataOptionsArgs) *string { + if v == nil { + return nil + } + return v.HttpEndpoint + }).(pulumi.StringPtrOutput) +} + +// Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. +func (o MetadataOptionsArgsPtrOutput) HttpProtocolIpv6() pulumi.StringPtrOutput { + return o.ApplyT(func(v *MetadataOptionsArgs) *string { + if v == nil { + return nil + } + return v.HttpProtocolIpv6 + }).(pulumi.StringPtrOutput) +} + +// HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. +func (o MetadataOptionsArgsPtrOutput) HttpPutResponseHopLimit() pulumi.IntPtrOutput { + return o.ApplyT(func(v *MetadataOptionsArgs) *int { + if v == nil { + return nil + } + return v.HttpPutResponseHopLimit + }).(pulumi.IntPtrOutput) +} + +// Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. +func (o MetadataOptionsArgsPtrOutput) HttpTokens() pulumi.StringPtrOutput { + return o.ApplyT(func(v *MetadataOptionsArgs) *string { + if v == nil { + return nil + } + return v.HttpTokens + }).(pulumi.StringPtrOutput) +} + +type NamePatternArgs struct { + // Optional regex flags (e.g. 'i' for case-insensitive). + Flags *string `pulumi:"flags"` + // Regular expression pattern to match workload names. + Pattern *string `pulumi:"pattern"` +} + +// NamePatternArgsInput is an input type that accepts NamePatternArgsArgs and NamePatternArgsOutput values. +// You can construct a concrete instance of `NamePatternArgsInput` via: +// +// NamePatternArgsArgs{...} +type NamePatternArgsInput interface { + pulumi.Input + + ToNamePatternArgsOutput() NamePatternArgsOutput + ToNamePatternArgsOutputWithContext(context.Context) NamePatternArgsOutput +} + +type NamePatternArgsArgs struct { + // Optional regex flags (e.g. 'i' for case-insensitive). + Flags pulumi.StringPtrInput `pulumi:"flags"` + // Regular expression pattern to match workload names. + Pattern pulumi.StringPtrInput `pulumi:"pattern"` +} + +func (NamePatternArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*NamePatternArgs)(nil)).Elem() +} + +func (i NamePatternArgsArgs) ToNamePatternArgsOutput() NamePatternArgsOutput { + return i.ToNamePatternArgsOutputWithContext(context.Background()) +} + +func (i NamePatternArgsArgs) ToNamePatternArgsOutputWithContext(ctx context.Context) NamePatternArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(NamePatternArgsOutput) +} + +func (i NamePatternArgsArgs) ToNamePatternArgsPtrOutput() NamePatternArgsPtrOutput { + return i.ToNamePatternArgsPtrOutputWithContext(context.Background()) +} + +func (i NamePatternArgsArgs) ToNamePatternArgsPtrOutputWithContext(ctx context.Context) NamePatternArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(NamePatternArgsOutput).ToNamePatternArgsPtrOutputWithContext(ctx) +} + +// NamePatternArgsPtrInput is an input type that accepts NamePatternArgsArgs, NamePatternArgsPtr and NamePatternArgsPtrOutput values. +// You can construct a concrete instance of `NamePatternArgsPtrInput` via: +// +// NamePatternArgsArgs{...} +// +// or: +// +// nil +type NamePatternArgsPtrInput interface { + pulumi.Input + + ToNamePatternArgsPtrOutput() NamePatternArgsPtrOutput + ToNamePatternArgsPtrOutputWithContext(context.Context) NamePatternArgsPtrOutput +} + +type namePatternArgsPtrType NamePatternArgsArgs + +func NamePatternArgsPtr(v *NamePatternArgsArgs) NamePatternArgsPtrInput { + return (*namePatternArgsPtrType)(v) +} + +func (*namePatternArgsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**NamePatternArgs)(nil)).Elem() +} + +func (i *namePatternArgsPtrType) ToNamePatternArgsPtrOutput() NamePatternArgsPtrOutput { + return i.ToNamePatternArgsPtrOutputWithContext(context.Background()) +} + +func (i *namePatternArgsPtrType) ToNamePatternArgsPtrOutputWithContext(ctx context.Context) NamePatternArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(NamePatternArgsPtrOutput) +} + +type NamePatternArgsOutput struct{ *pulumi.OutputState } + +func (NamePatternArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*NamePatternArgs)(nil)).Elem() +} + +func (o NamePatternArgsOutput) ToNamePatternArgsOutput() NamePatternArgsOutput { + return o +} + +func (o NamePatternArgsOutput) ToNamePatternArgsOutputWithContext(ctx context.Context) NamePatternArgsOutput { + return o +} + +func (o NamePatternArgsOutput) ToNamePatternArgsPtrOutput() NamePatternArgsPtrOutput { + return o.ToNamePatternArgsPtrOutputWithContext(context.Background()) +} + +func (o NamePatternArgsOutput) ToNamePatternArgsPtrOutputWithContext(ctx context.Context) NamePatternArgsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v NamePatternArgs) *NamePatternArgs { + return &v + }).(NamePatternArgsPtrOutput) +} + +// Optional regex flags (e.g. 'i' for case-insensitive). +func (o NamePatternArgsOutput) Flags() pulumi.StringPtrOutput { + return o.ApplyT(func(v NamePatternArgs) *string { return v.Flags }).(pulumi.StringPtrOutput) +} + +// Regular expression pattern to match workload names. +func (o NamePatternArgsOutput) Pattern() pulumi.StringPtrOutput { + return o.ApplyT(func(v NamePatternArgs) *string { return v.Pattern }).(pulumi.StringPtrOutput) +} + +type NamePatternArgsPtrOutput struct{ *pulumi.OutputState } + +func (NamePatternArgsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**NamePatternArgs)(nil)).Elem() +} + +func (o NamePatternArgsPtrOutput) ToNamePatternArgsPtrOutput() NamePatternArgsPtrOutput { + return o +} + +func (o NamePatternArgsPtrOutput) ToNamePatternArgsPtrOutputWithContext(ctx context.Context) NamePatternArgsPtrOutput { + return o +} + +func (o NamePatternArgsPtrOutput) Elem() NamePatternArgsOutput { + return o.ApplyT(func(v *NamePatternArgs) NamePatternArgs { + if v != nil { + return *v + } + var ret NamePatternArgs + return ret + }).(NamePatternArgsOutput) +} + +// Optional regex flags (e.g. 'i' for case-insensitive). +func (o NamePatternArgsPtrOutput) Flags() pulumi.StringPtrOutput { + return o.ApplyT(func(v *NamePatternArgs) *string { + if v == nil { + return nil + } + return v.Flags + }).(pulumi.StringPtrOutput) +} + +// Regular expression pattern to match workload names. +func (o NamePatternArgsPtrOutput) Pattern() pulumi.StringPtrOutput { + return o.ApplyT(func(v *NamePatternArgs) *string { + if v == nil { + return nil + } + return v.Pattern + }).(pulumi.StringPtrOutput) +} + +type OCIBootConfigArgs struct { + // Boot volume size in GB. Example: 100. + BootVolumeSizeInGbs *int `pulumi:"bootVolumeSizeInGbs"` + // Boot volume performance units per GB. Example: 10. + BootVolumeVpusPerGb *int `pulumi:"bootVolumeVpusPerGb"` +} + +// OCIBootConfigArgsInput is an input type that accepts OCIBootConfigArgsArgs and OCIBootConfigArgsOutput values. +// You can construct a concrete instance of `OCIBootConfigArgsInput` via: +// +// OCIBootConfigArgsArgs{...} +type OCIBootConfigArgsInput interface { + pulumi.Input + + ToOCIBootConfigArgsOutput() OCIBootConfigArgsOutput + ToOCIBootConfigArgsOutputWithContext(context.Context) OCIBootConfigArgsOutput +} + +type OCIBootConfigArgsArgs struct { + // Boot volume size in GB. Example: 100. + BootVolumeSizeInGbs pulumi.IntPtrInput `pulumi:"bootVolumeSizeInGbs"` + // Boot volume performance units per GB. Example: 10. + BootVolumeVpusPerGb pulumi.IntPtrInput `pulumi:"bootVolumeVpusPerGb"` +} + +func (OCIBootConfigArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OCIBootConfigArgs)(nil)).Elem() +} + +func (i OCIBootConfigArgsArgs) ToOCIBootConfigArgsOutput() OCIBootConfigArgsOutput { + return i.ToOCIBootConfigArgsOutputWithContext(context.Background()) +} + +func (i OCIBootConfigArgsArgs) ToOCIBootConfigArgsOutputWithContext(ctx context.Context) OCIBootConfigArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCIBootConfigArgsOutput) +} + +func (i OCIBootConfigArgsArgs) ToOCIBootConfigArgsPtrOutput() OCIBootConfigArgsPtrOutput { + return i.ToOCIBootConfigArgsPtrOutputWithContext(context.Background()) +} + +func (i OCIBootConfigArgsArgs) ToOCIBootConfigArgsPtrOutputWithContext(ctx context.Context) OCIBootConfigArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCIBootConfigArgsOutput).ToOCIBootConfigArgsPtrOutputWithContext(ctx) +} + +// OCIBootConfigArgsPtrInput is an input type that accepts OCIBootConfigArgsArgs, OCIBootConfigArgsPtr and OCIBootConfigArgsPtrOutput values. +// You can construct a concrete instance of `OCIBootConfigArgsPtrInput` via: +// +// OCIBootConfigArgsArgs{...} +// +// or: +// +// nil +type OCIBootConfigArgsPtrInput interface { + pulumi.Input + + ToOCIBootConfigArgsPtrOutput() OCIBootConfigArgsPtrOutput + ToOCIBootConfigArgsPtrOutputWithContext(context.Context) OCIBootConfigArgsPtrOutput +} + +type ocibootConfigArgsPtrType OCIBootConfigArgsArgs + +func OCIBootConfigArgsPtr(v *OCIBootConfigArgsArgs) OCIBootConfigArgsPtrInput { + return (*ocibootConfigArgsPtrType)(v) +} + +func (*ocibootConfigArgsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OCIBootConfigArgs)(nil)).Elem() +} + +func (i *ocibootConfigArgsPtrType) ToOCIBootConfigArgsPtrOutput() OCIBootConfigArgsPtrOutput { + return i.ToOCIBootConfigArgsPtrOutputWithContext(context.Background()) +} + +func (i *ocibootConfigArgsPtrType) ToOCIBootConfigArgsPtrOutputWithContext(ctx context.Context) OCIBootConfigArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCIBootConfigArgsPtrOutput) +} + +type OCIBootConfigArgsOutput struct{ *pulumi.OutputState } + +func (OCIBootConfigArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OCIBootConfigArgs)(nil)).Elem() +} + +func (o OCIBootConfigArgsOutput) ToOCIBootConfigArgsOutput() OCIBootConfigArgsOutput { + return o +} + +func (o OCIBootConfigArgsOutput) ToOCIBootConfigArgsOutputWithContext(ctx context.Context) OCIBootConfigArgsOutput { + return o +} + +func (o OCIBootConfigArgsOutput) ToOCIBootConfigArgsPtrOutput() OCIBootConfigArgsPtrOutput { + return o.ToOCIBootConfigArgsPtrOutputWithContext(context.Background()) +} + +func (o OCIBootConfigArgsOutput) ToOCIBootConfigArgsPtrOutputWithContext(ctx context.Context) OCIBootConfigArgsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OCIBootConfigArgs) *OCIBootConfigArgs { + return &v + }).(OCIBootConfigArgsPtrOutput) +} + +// Boot volume size in GB. Example: 100. +func (o OCIBootConfigArgsOutput) BootVolumeSizeInGbs() pulumi.IntPtrOutput { + return o.ApplyT(func(v OCIBootConfigArgs) *int { return v.BootVolumeSizeInGbs }).(pulumi.IntPtrOutput) +} + +// Boot volume performance units per GB. Example: 10. +func (o OCIBootConfigArgsOutput) BootVolumeVpusPerGb() pulumi.IntPtrOutput { + return o.ApplyT(func(v OCIBootConfigArgs) *int { return v.BootVolumeVpusPerGb }).(pulumi.IntPtrOutput) +} + +type OCIBootConfigArgsPtrOutput struct{ *pulumi.OutputState } + +func (OCIBootConfigArgsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OCIBootConfigArgs)(nil)).Elem() +} + +func (o OCIBootConfigArgsPtrOutput) ToOCIBootConfigArgsPtrOutput() OCIBootConfigArgsPtrOutput { + return o +} + +func (o OCIBootConfigArgsPtrOutput) ToOCIBootConfigArgsPtrOutputWithContext(ctx context.Context) OCIBootConfigArgsPtrOutput { + return o +} + +func (o OCIBootConfigArgsPtrOutput) Elem() OCIBootConfigArgsOutput { + return o.ApplyT(func(v *OCIBootConfigArgs) OCIBootConfigArgs { + if v != nil { + return *v + } + var ret OCIBootConfigArgs + return ret + }).(OCIBootConfigArgsOutput) +} + +// Boot volume size in GB. Example: 100. +func (o OCIBootConfigArgsPtrOutput) BootVolumeSizeInGbs() pulumi.IntPtrOutput { + return o.ApplyT(func(v *OCIBootConfigArgs) *int { + if v == nil { + return nil + } + return v.BootVolumeSizeInGbs + }).(pulumi.IntPtrOutput) +} + +// Boot volume performance units per GB. Example: 10. +func (o OCIBootConfigArgsPtrOutput) BootVolumeVpusPerGb() pulumi.IntPtrOutput { + return o.ApplyT(func(v *OCIBootConfigArgs) *int { + if v == nil { + return nil + } + return v.BootVolumeVpusPerGb + }).(pulumi.IntPtrOutput) +} + +type OCIImageSelectorTermArgs struct { + // OCID of the compartment containing the image. Example: 'ocid1.compartment.oc1..aaaaaaaa'. + CompartmentId *string `pulumi:"compartmentId"` + // Explicit OCI image OCID. Example: 'ocid1.image.oc1..aaaaaaaa'. + Id *string `pulumi:"id"` + // OCI image display name filter. Example: 'Oracle-Linux-8.9'. + Name *string `pulumi:"name"` +} + +// OCIImageSelectorTermArgsInput is an input type that accepts OCIImageSelectorTermArgsArgs and OCIImageSelectorTermArgsOutput values. +// You can construct a concrete instance of `OCIImageSelectorTermArgsInput` via: +// +// OCIImageSelectorTermArgsArgs{...} +type OCIImageSelectorTermArgsInput interface { + pulumi.Input + + ToOCIImageSelectorTermArgsOutput() OCIImageSelectorTermArgsOutput + ToOCIImageSelectorTermArgsOutputWithContext(context.Context) OCIImageSelectorTermArgsOutput +} + +type OCIImageSelectorTermArgsArgs struct { + // OCID of the compartment containing the image. Example: 'ocid1.compartment.oc1..aaaaaaaa'. + CompartmentId pulumi.StringPtrInput `pulumi:"compartmentId"` + // Explicit OCI image OCID. Example: 'ocid1.image.oc1..aaaaaaaa'. + Id pulumi.StringPtrInput `pulumi:"id"` + // OCI image display name filter. Example: 'Oracle-Linux-8.9'. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (OCIImageSelectorTermArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OCIImageSelectorTermArgs)(nil)).Elem() +} + +func (i OCIImageSelectorTermArgsArgs) ToOCIImageSelectorTermArgsOutput() OCIImageSelectorTermArgsOutput { + return i.ToOCIImageSelectorTermArgsOutputWithContext(context.Background()) +} + +func (i OCIImageSelectorTermArgsArgs) ToOCIImageSelectorTermArgsOutputWithContext(ctx context.Context) OCIImageSelectorTermArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCIImageSelectorTermArgsOutput) +} + +// OCIImageSelectorTermArgsArrayInput is an input type that accepts OCIImageSelectorTermArgsArray and OCIImageSelectorTermArgsArrayOutput values. +// You can construct a concrete instance of `OCIImageSelectorTermArgsArrayInput` via: +// +// OCIImageSelectorTermArgsArray{ OCIImageSelectorTermArgsArgs{...} } +type OCIImageSelectorTermArgsArrayInput interface { + pulumi.Input + + ToOCIImageSelectorTermArgsArrayOutput() OCIImageSelectorTermArgsArrayOutput + ToOCIImageSelectorTermArgsArrayOutputWithContext(context.Context) OCIImageSelectorTermArgsArrayOutput +} + +type OCIImageSelectorTermArgsArray []OCIImageSelectorTermArgsInput + +func (OCIImageSelectorTermArgsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]OCIImageSelectorTermArgs)(nil)).Elem() +} + +func (i OCIImageSelectorTermArgsArray) ToOCIImageSelectorTermArgsArrayOutput() OCIImageSelectorTermArgsArrayOutput { + return i.ToOCIImageSelectorTermArgsArrayOutputWithContext(context.Background()) +} + +func (i OCIImageSelectorTermArgsArray) ToOCIImageSelectorTermArgsArrayOutputWithContext(ctx context.Context) OCIImageSelectorTermArgsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCIImageSelectorTermArgsArrayOutput) +} + +type OCIImageSelectorTermArgsOutput struct{ *pulumi.OutputState } + +func (OCIImageSelectorTermArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OCIImageSelectorTermArgs)(nil)).Elem() +} + +func (o OCIImageSelectorTermArgsOutput) ToOCIImageSelectorTermArgsOutput() OCIImageSelectorTermArgsOutput { + return o +} + +func (o OCIImageSelectorTermArgsOutput) ToOCIImageSelectorTermArgsOutputWithContext(ctx context.Context) OCIImageSelectorTermArgsOutput { + return o +} + +// OCID of the compartment containing the image. Example: 'ocid1.compartment.oc1..aaaaaaaa'. +func (o OCIImageSelectorTermArgsOutput) CompartmentId() pulumi.StringPtrOutput { + return o.ApplyT(func(v OCIImageSelectorTermArgs) *string { return v.CompartmentId }).(pulumi.StringPtrOutput) +} + +// Explicit OCI image OCID. Example: 'ocid1.image.oc1..aaaaaaaa'. +func (o OCIImageSelectorTermArgsOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v OCIImageSelectorTermArgs) *string { return v.Id }).(pulumi.StringPtrOutput) +} + +// OCI image display name filter. Example: 'Oracle-Linux-8.9'. +func (o OCIImageSelectorTermArgsOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v OCIImageSelectorTermArgs) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +type OCIImageSelectorTermArgsArrayOutput struct{ *pulumi.OutputState } + +func (OCIImageSelectorTermArgsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]OCIImageSelectorTermArgs)(nil)).Elem() +} + +func (o OCIImageSelectorTermArgsArrayOutput) ToOCIImageSelectorTermArgsArrayOutput() OCIImageSelectorTermArgsArrayOutput { + return o +} + +func (o OCIImageSelectorTermArgsArrayOutput) ToOCIImageSelectorTermArgsArrayOutputWithContext(ctx context.Context) OCIImageSelectorTermArgsArrayOutput { + return o +} + +func (o OCIImageSelectorTermArgsArrayOutput) Index(i pulumi.IntInput) OCIImageSelectorTermArgsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) OCIImageSelectorTermArgs { + return vs[0].([]OCIImageSelectorTermArgs)[vs[1].(int)] + }).(OCIImageSelectorTermArgsOutput) +} + +type OCILaunchOptionsArgs struct { + // Emulation type for the boot volume. Example: 'PARAVIRTUALIZED'. + BootVolumeType *string `pulumi:"bootVolumeType"` + // Firmware used to boot the instance. Example: 'UEFI_64'. + Firmware *string `pulumi:"firmware"` + // Whether consistent volume naming is enabled for the instance. Example: true. + IsConsistentVolumeNamingEnabled *bool `pulumi:"isConsistentVolumeNamingEnabled"` + // Emulation type for the network interface. Example: 'PARAVIRTUALIZED'. + NetworkType *string `pulumi:"networkType"` + // Emulation type for remote data volumes. Example: 'PARAVIRTUALIZED'. + RemoteDataVolumeType *string `pulumi:"remoteDataVolumeType"` +} + +// OCILaunchOptionsArgsInput is an input type that accepts OCILaunchOptionsArgsArgs and OCILaunchOptionsArgsOutput values. +// You can construct a concrete instance of `OCILaunchOptionsArgsInput` via: +// +// OCILaunchOptionsArgsArgs{...} +type OCILaunchOptionsArgsInput interface { + pulumi.Input + + ToOCILaunchOptionsArgsOutput() OCILaunchOptionsArgsOutput + ToOCILaunchOptionsArgsOutputWithContext(context.Context) OCILaunchOptionsArgsOutput +} + +type OCILaunchOptionsArgsArgs struct { + // Emulation type for the boot volume. Example: 'PARAVIRTUALIZED'. + BootVolumeType pulumi.StringPtrInput `pulumi:"bootVolumeType"` + // Firmware used to boot the instance. Example: 'UEFI_64'. + Firmware pulumi.StringPtrInput `pulumi:"firmware"` + // Whether consistent volume naming is enabled for the instance. Example: true. + IsConsistentVolumeNamingEnabled pulumi.BoolPtrInput `pulumi:"isConsistentVolumeNamingEnabled"` + // Emulation type for the network interface. Example: 'PARAVIRTUALIZED'. + NetworkType pulumi.StringPtrInput `pulumi:"networkType"` + // Emulation type for remote data volumes. Example: 'PARAVIRTUALIZED'. + RemoteDataVolumeType pulumi.StringPtrInput `pulumi:"remoteDataVolumeType"` +} + +func (OCILaunchOptionsArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OCILaunchOptionsArgs)(nil)).Elem() +} + +func (i OCILaunchOptionsArgsArgs) ToOCILaunchOptionsArgsOutput() OCILaunchOptionsArgsOutput { + return i.ToOCILaunchOptionsArgsOutputWithContext(context.Background()) +} + +func (i OCILaunchOptionsArgsArgs) ToOCILaunchOptionsArgsOutputWithContext(ctx context.Context) OCILaunchOptionsArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCILaunchOptionsArgsOutput) +} + +func (i OCILaunchOptionsArgsArgs) ToOCILaunchOptionsArgsPtrOutput() OCILaunchOptionsArgsPtrOutput { + return i.ToOCILaunchOptionsArgsPtrOutputWithContext(context.Background()) +} + +func (i OCILaunchOptionsArgsArgs) ToOCILaunchOptionsArgsPtrOutputWithContext(ctx context.Context) OCILaunchOptionsArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCILaunchOptionsArgsOutput).ToOCILaunchOptionsArgsPtrOutputWithContext(ctx) +} + +// OCILaunchOptionsArgsPtrInput is an input type that accepts OCILaunchOptionsArgsArgs, OCILaunchOptionsArgsPtr and OCILaunchOptionsArgsPtrOutput values. +// You can construct a concrete instance of `OCILaunchOptionsArgsPtrInput` via: +// +// OCILaunchOptionsArgsArgs{...} +// +// or: +// +// nil +type OCILaunchOptionsArgsPtrInput interface { + pulumi.Input + + ToOCILaunchOptionsArgsPtrOutput() OCILaunchOptionsArgsPtrOutput + ToOCILaunchOptionsArgsPtrOutputWithContext(context.Context) OCILaunchOptionsArgsPtrOutput +} + +type ocilaunchOptionsArgsPtrType OCILaunchOptionsArgsArgs + +func OCILaunchOptionsArgsPtr(v *OCILaunchOptionsArgsArgs) OCILaunchOptionsArgsPtrInput { + return (*ocilaunchOptionsArgsPtrType)(v) +} + +func (*ocilaunchOptionsArgsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OCILaunchOptionsArgs)(nil)).Elem() +} + +func (i *ocilaunchOptionsArgsPtrType) ToOCILaunchOptionsArgsPtrOutput() OCILaunchOptionsArgsPtrOutput { + return i.ToOCILaunchOptionsArgsPtrOutputWithContext(context.Background()) +} + +func (i *ocilaunchOptionsArgsPtrType) ToOCILaunchOptionsArgsPtrOutputWithContext(ctx context.Context) OCILaunchOptionsArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCILaunchOptionsArgsPtrOutput) +} + +type OCILaunchOptionsArgsOutput struct{ *pulumi.OutputState } + +func (OCILaunchOptionsArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OCILaunchOptionsArgs)(nil)).Elem() +} + +func (o OCILaunchOptionsArgsOutput) ToOCILaunchOptionsArgsOutput() OCILaunchOptionsArgsOutput { + return o +} + +func (o OCILaunchOptionsArgsOutput) ToOCILaunchOptionsArgsOutputWithContext(ctx context.Context) OCILaunchOptionsArgsOutput { + return o +} + +func (o OCILaunchOptionsArgsOutput) ToOCILaunchOptionsArgsPtrOutput() OCILaunchOptionsArgsPtrOutput { + return o.ToOCILaunchOptionsArgsPtrOutputWithContext(context.Background()) +} + +func (o OCILaunchOptionsArgsOutput) ToOCILaunchOptionsArgsPtrOutputWithContext(ctx context.Context) OCILaunchOptionsArgsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OCILaunchOptionsArgs) *OCILaunchOptionsArgs { + return &v + }).(OCILaunchOptionsArgsPtrOutput) +} + +// Emulation type for the boot volume. Example: 'PARAVIRTUALIZED'. +func (o OCILaunchOptionsArgsOutput) BootVolumeType() pulumi.StringPtrOutput { + return o.ApplyT(func(v OCILaunchOptionsArgs) *string { return v.BootVolumeType }).(pulumi.StringPtrOutput) +} + +// Firmware used to boot the instance. Example: 'UEFI_64'. +func (o OCILaunchOptionsArgsOutput) Firmware() pulumi.StringPtrOutput { + return o.ApplyT(func(v OCILaunchOptionsArgs) *string { return v.Firmware }).(pulumi.StringPtrOutput) +} + +// Whether consistent volume naming is enabled for the instance. Example: true. +func (o OCILaunchOptionsArgsOutput) IsConsistentVolumeNamingEnabled() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OCILaunchOptionsArgs) *bool { return v.IsConsistentVolumeNamingEnabled }).(pulumi.BoolPtrOutput) +} + +// Emulation type for the network interface. Example: 'PARAVIRTUALIZED'. +func (o OCILaunchOptionsArgsOutput) NetworkType() pulumi.StringPtrOutput { + return o.ApplyT(func(v OCILaunchOptionsArgs) *string { return v.NetworkType }).(pulumi.StringPtrOutput) +} + +// Emulation type for remote data volumes. Example: 'PARAVIRTUALIZED'. +func (o OCILaunchOptionsArgsOutput) RemoteDataVolumeType() pulumi.StringPtrOutput { + return o.ApplyT(func(v OCILaunchOptionsArgs) *string { return v.RemoteDataVolumeType }).(pulumi.StringPtrOutput) +} + +type OCILaunchOptionsArgsPtrOutput struct{ *pulumi.OutputState } + +func (OCILaunchOptionsArgsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OCILaunchOptionsArgs)(nil)).Elem() +} + +func (o OCILaunchOptionsArgsPtrOutput) ToOCILaunchOptionsArgsPtrOutput() OCILaunchOptionsArgsPtrOutput { + return o +} + +func (o OCILaunchOptionsArgsPtrOutput) ToOCILaunchOptionsArgsPtrOutputWithContext(ctx context.Context) OCILaunchOptionsArgsPtrOutput { + return o +} + +func (o OCILaunchOptionsArgsPtrOutput) Elem() OCILaunchOptionsArgsOutput { + return o.ApplyT(func(v *OCILaunchOptionsArgs) OCILaunchOptionsArgs { + if v != nil { + return *v + } + var ret OCILaunchOptionsArgs + return ret + }).(OCILaunchOptionsArgsOutput) +} + +// Emulation type for the boot volume. Example: 'PARAVIRTUALIZED'. +func (o OCILaunchOptionsArgsPtrOutput) BootVolumeType() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OCILaunchOptionsArgs) *string { + if v == nil { + return nil + } + return v.BootVolumeType + }).(pulumi.StringPtrOutput) +} + +// Firmware used to boot the instance. Example: 'UEFI_64'. +func (o OCILaunchOptionsArgsPtrOutput) Firmware() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OCILaunchOptionsArgs) *string { + if v == nil { + return nil + } + return v.Firmware + }).(pulumi.StringPtrOutput) +} + +// Whether consistent volume naming is enabled for the instance. Example: true. +func (o OCILaunchOptionsArgsPtrOutput) IsConsistentVolumeNamingEnabled() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OCILaunchOptionsArgs) *bool { + if v == nil { + return nil + } + return v.IsConsistentVolumeNamingEnabled + }).(pulumi.BoolPtrOutput) +} + +// Emulation type for the network interface. Example: 'PARAVIRTUALIZED'. +func (o OCILaunchOptionsArgsPtrOutput) NetworkType() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OCILaunchOptionsArgs) *string { + if v == nil { + return nil + } + return v.NetworkType + }).(pulumi.StringPtrOutput) +} + +// Emulation type for remote data volumes. Example: 'PARAVIRTUALIZED'. +func (o OCILaunchOptionsArgsPtrOutput) RemoteDataVolumeType() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OCILaunchOptionsArgs) *string { + if v == nil { + return nil + } + return v.RemoteDataVolumeType + }).(pulumi.StringPtrOutput) +} + +type OCINodeClassSpecArgs struct { + // OCI compute instance agent plugins to enable. Example: ["Compute Instance Monitoring"]. + AgentList []string `pulumi:"agentList"` + // Additional block volumes attached to provisioned nodes. + BlockDevices []OCIVolumeAttributesArgs `pulumi:"blockDevices"` + // Boot volume configuration for provisioned nodes. + BootConfig *OCIBootConfigArgs `pulumi:"bootConfig"` + // OCI free-form tags applied to all resources created by this node class. Example: {"environment": "production"}. + FreeFormTags map[string]string `pulumi:"freeFormTags"` + // OCI node image family shorthand used when no imageSelector is specified. Example: 'Oracle-Linux-8'. + ImageFamily *string `pulumi:"imageFamily"` + // Selectors for the images used to launch nodes. Example: [{name: "Oracle-Linux-8.9"}]. + ImageSelector []OCIImageSelectorTermArgs `pulumi:"imageSelector"` + // Instance launch options controlling firmware and network/volume emulation type. + LaunchOptions *OCILaunchOptionsArgs `pulumi:"launchOptions"` + // OCI instance metadata applied to provisioned nodes. Example: {"ssh_authorized_keys": "ssh-rsa ..."}. + MetaData map[string]string `pulumi:"metaData"` + // Script executed before node bootstrap. Example: '#!/bin/bash\necho pre-install'. + PreInstallScript *string `pulumi:"preInstallScript"` + // Selectors for network security groups attached to provisioned nodes. + SecurityGroupSelector []OCISecurityGroupSelectorTermArgs `pulumi:"securityGroupSelector"` + // Selectors for the subnets nodes will be launched into. + SubnetSelector []OCISubnetSelectorTermArgs `pulumi:"subnetSelector"` + // OCI defined tags applied to all resources created by this node class. + Tags map[string]string `pulumi:"tags"` + // Custom cloud-init user data merged into the node launch config (base64 or plain text). Example: '#!/bin/bash\necho hello'. + UserData *string `pulumi:"userData"` + // OCID of the VCN nodes will be launched into. Example: 'ocid1.vcn.oc1..aaaaaaaa'. + VcnId *string `pulumi:"vcnId"` +} + +// OCINodeClassSpecArgsInput is an input type that accepts OCINodeClassSpecArgsArgs and OCINodeClassSpecArgsOutput values. +// You can construct a concrete instance of `OCINodeClassSpecArgsInput` via: +// +// OCINodeClassSpecArgsArgs{...} +type OCINodeClassSpecArgsInput interface { + pulumi.Input + + ToOCINodeClassSpecArgsOutput() OCINodeClassSpecArgsOutput + ToOCINodeClassSpecArgsOutputWithContext(context.Context) OCINodeClassSpecArgsOutput +} + +type OCINodeClassSpecArgsArgs struct { + // OCI compute instance agent plugins to enable. Example: ["Compute Instance Monitoring"]. + AgentList pulumi.StringArrayInput `pulumi:"agentList"` + // Additional block volumes attached to provisioned nodes. + BlockDevices OCIVolumeAttributesArgsArrayInput `pulumi:"blockDevices"` + // Boot volume configuration for provisioned nodes. + BootConfig OCIBootConfigArgsPtrInput `pulumi:"bootConfig"` + // OCI free-form tags applied to all resources created by this node class. Example: {"environment": "production"}. + FreeFormTags pulumi.StringMapInput `pulumi:"freeFormTags"` + // OCI node image family shorthand used when no imageSelector is specified. Example: 'Oracle-Linux-8'. + ImageFamily pulumi.StringPtrInput `pulumi:"imageFamily"` + // Selectors for the images used to launch nodes. Example: [{name: "Oracle-Linux-8.9"}]. + ImageSelector OCIImageSelectorTermArgsArrayInput `pulumi:"imageSelector"` + // Instance launch options controlling firmware and network/volume emulation type. + LaunchOptions OCILaunchOptionsArgsPtrInput `pulumi:"launchOptions"` + // OCI instance metadata applied to provisioned nodes. Example: {"ssh_authorized_keys": "ssh-rsa ..."}. + MetaData pulumi.StringMapInput `pulumi:"metaData"` + // Script executed before node bootstrap. Example: '#!/bin/bash\necho pre-install'. + PreInstallScript pulumi.StringPtrInput `pulumi:"preInstallScript"` + // Selectors for network security groups attached to provisioned nodes. + SecurityGroupSelector OCISecurityGroupSelectorTermArgsArrayInput `pulumi:"securityGroupSelector"` + // Selectors for the subnets nodes will be launched into. + SubnetSelector OCISubnetSelectorTermArgsArrayInput `pulumi:"subnetSelector"` + // OCI defined tags applied to all resources created by this node class. + Tags pulumi.StringMapInput `pulumi:"tags"` + // Custom cloud-init user data merged into the node launch config (base64 or plain text). Example: '#!/bin/bash\necho hello'. + UserData pulumi.StringPtrInput `pulumi:"userData"` + // OCID of the VCN nodes will be launched into. Example: 'ocid1.vcn.oc1..aaaaaaaa'. + VcnId pulumi.StringPtrInput `pulumi:"vcnId"` +} + +func (OCINodeClassSpecArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OCINodeClassSpecArgs)(nil)).Elem() +} + +func (i OCINodeClassSpecArgsArgs) ToOCINodeClassSpecArgsOutput() OCINodeClassSpecArgsOutput { + return i.ToOCINodeClassSpecArgsOutputWithContext(context.Background()) +} + +func (i OCINodeClassSpecArgsArgs) ToOCINodeClassSpecArgsOutputWithContext(ctx context.Context) OCINodeClassSpecArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCINodeClassSpecArgsOutput) +} + +func (i OCINodeClassSpecArgsArgs) ToOCINodeClassSpecArgsPtrOutput() OCINodeClassSpecArgsPtrOutput { + return i.ToOCINodeClassSpecArgsPtrOutputWithContext(context.Background()) +} + +func (i OCINodeClassSpecArgsArgs) ToOCINodeClassSpecArgsPtrOutputWithContext(ctx context.Context) OCINodeClassSpecArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCINodeClassSpecArgsOutput).ToOCINodeClassSpecArgsPtrOutputWithContext(ctx) +} + +// OCINodeClassSpecArgsPtrInput is an input type that accepts OCINodeClassSpecArgsArgs, OCINodeClassSpecArgsPtr and OCINodeClassSpecArgsPtrOutput values. +// You can construct a concrete instance of `OCINodeClassSpecArgsPtrInput` via: +// +// OCINodeClassSpecArgsArgs{...} +// +// or: +// +// nil +type OCINodeClassSpecArgsPtrInput interface { + pulumi.Input + + ToOCINodeClassSpecArgsPtrOutput() OCINodeClassSpecArgsPtrOutput + ToOCINodeClassSpecArgsPtrOutputWithContext(context.Context) OCINodeClassSpecArgsPtrOutput +} + +type ocinodeClassSpecArgsPtrType OCINodeClassSpecArgsArgs + +func OCINodeClassSpecArgsPtr(v *OCINodeClassSpecArgsArgs) OCINodeClassSpecArgsPtrInput { + return (*ocinodeClassSpecArgsPtrType)(v) +} + +func (*ocinodeClassSpecArgsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OCINodeClassSpecArgs)(nil)).Elem() +} + +func (i *ocinodeClassSpecArgsPtrType) ToOCINodeClassSpecArgsPtrOutput() OCINodeClassSpecArgsPtrOutput { + return i.ToOCINodeClassSpecArgsPtrOutputWithContext(context.Background()) +} + +func (i *ocinodeClassSpecArgsPtrType) ToOCINodeClassSpecArgsPtrOutputWithContext(ctx context.Context) OCINodeClassSpecArgsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCINodeClassSpecArgsPtrOutput) +} + +type OCINodeClassSpecArgsOutput struct{ *pulumi.OutputState } + +func (OCINodeClassSpecArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OCINodeClassSpecArgs)(nil)).Elem() +} + +func (o OCINodeClassSpecArgsOutput) ToOCINodeClassSpecArgsOutput() OCINodeClassSpecArgsOutput { + return o +} + +func (o OCINodeClassSpecArgsOutput) ToOCINodeClassSpecArgsOutputWithContext(ctx context.Context) OCINodeClassSpecArgsOutput { + return o +} + +func (o OCINodeClassSpecArgsOutput) ToOCINodeClassSpecArgsPtrOutput() OCINodeClassSpecArgsPtrOutput { + return o.ToOCINodeClassSpecArgsPtrOutputWithContext(context.Background()) +} + +func (o OCINodeClassSpecArgsOutput) ToOCINodeClassSpecArgsPtrOutputWithContext(ctx context.Context) OCINodeClassSpecArgsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OCINodeClassSpecArgs) *OCINodeClassSpecArgs { + return &v + }).(OCINodeClassSpecArgsPtrOutput) +} + +// OCI compute instance agent plugins to enable. Example: ["Compute Instance Monitoring"]. +func (o OCINodeClassSpecArgsOutput) AgentList() pulumi.StringArrayOutput { + return o.ApplyT(func(v OCINodeClassSpecArgs) []string { return v.AgentList }).(pulumi.StringArrayOutput) +} + +// Additional block volumes attached to provisioned nodes. +func (o OCINodeClassSpecArgsOutput) BlockDevices() OCIVolumeAttributesArgsArrayOutput { + return o.ApplyT(func(v OCINodeClassSpecArgs) []OCIVolumeAttributesArgs { return v.BlockDevices }).(OCIVolumeAttributesArgsArrayOutput) +} + +// Boot volume configuration for provisioned nodes. +func (o OCINodeClassSpecArgsOutput) BootConfig() OCIBootConfigArgsPtrOutput { + return o.ApplyT(func(v OCINodeClassSpecArgs) *OCIBootConfigArgs { return v.BootConfig }).(OCIBootConfigArgsPtrOutput) +} + +// OCI free-form tags applied to all resources created by this node class. Example: {"environment": "production"}. +func (o OCINodeClassSpecArgsOutput) FreeFormTags() pulumi.StringMapOutput { + return o.ApplyT(func(v OCINodeClassSpecArgs) map[string]string { return v.FreeFormTags }).(pulumi.StringMapOutput) +} + +// OCI node image family shorthand used when no imageSelector is specified. Example: 'Oracle-Linux-8'. +func (o OCINodeClassSpecArgsOutput) ImageFamily() pulumi.StringPtrOutput { + return o.ApplyT(func(v OCINodeClassSpecArgs) *string { return v.ImageFamily }).(pulumi.StringPtrOutput) +} + +// Selectors for the images used to launch nodes. Example: [{name: "Oracle-Linux-8.9"}]. +func (o OCINodeClassSpecArgsOutput) ImageSelector() OCIImageSelectorTermArgsArrayOutput { + return o.ApplyT(func(v OCINodeClassSpecArgs) []OCIImageSelectorTermArgs { return v.ImageSelector }).(OCIImageSelectorTermArgsArrayOutput) +} + +// Instance launch options controlling firmware and network/volume emulation type. +func (o OCINodeClassSpecArgsOutput) LaunchOptions() OCILaunchOptionsArgsPtrOutput { + return o.ApplyT(func(v OCINodeClassSpecArgs) *OCILaunchOptionsArgs { return v.LaunchOptions }).(OCILaunchOptionsArgsPtrOutput) +} + +// OCI instance metadata applied to provisioned nodes. Example: {"ssh_authorized_keys": "ssh-rsa ..."}. +func (o OCINodeClassSpecArgsOutput) MetaData() pulumi.StringMapOutput { + return o.ApplyT(func(v OCINodeClassSpecArgs) map[string]string { return v.MetaData }).(pulumi.StringMapOutput) +} + +// Script executed before node bootstrap. Example: '#!/bin/bash\necho pre-install'. +func (o OCINodeClassSpecArgsOutput) PreInstallScript() pulumi.StringPtrOutput { + return o.ApplyT(func(v OCINodeClassSpecArgs) *string { return v.PreInstallScript }).(pulumi.StringPtrOutput) +} + +// Selectors for network security groups attached to provisioned nodes. +func (o OCINodeClassSpecArgsOutput) SecurityGroupSelector() OCISecurityGroupSelectorTermArgsArrayOutput { + return o.ApplyT(func(v OCINodeClassSpecArgs) []OCISecurityGroupSelectorTermArgs { return v.SecurityGroupSelector }).(OCISecurityGroupSelectorTermArgsArrayOutput) +} + +// Selectors for the subnets nodes will be launched into. +func (o OCINodeClassSpecArgsOutput) SubnetSelector() OCISubnetSelectorTermArgsArrayOutput { + return o.ApplyT(func(v OCINodeClassSpecArgs) []OCISubnetSelectorTermArgs { return v.SubnetSelector }).(OCISubnetSelectorTermArgsArrayOutput) +} + +// OCI defined tags applied to all resources created by this node class. +func (o OCINodeClassSpecArgsOutput) Tags() pulumi.StringMapOutput { + return o.ApplyT(func(v OCINodeClassSpecArgs) map[string]string { return v.Tags }).(pulumi.StringMapOutput) +} + +// Custom cloud-init user data merged into the node launch config (base64 or plain text). Example: '#!/bin/bash\necho hello'. +func (o OCINodeClassSpecArgsOutput) UserData() pulumi.StringPtrOutput { + return o.ApplyT(func(v OCINodeClassSpecArgs) *string { return v.UserData }).(pulumi.StringPtrOutput) +} + +// OCID of the VCN nodes will be launched into. Example: 'ocid1.vcn.oc1..aaaaaaaa'. +func (o OCINodeClassSpecArgsOutput) VcnId() pulumi.StringPtrOutput { + return o.ApplyT(func(v OCINodeClassSpecArgs) *string { return v.VcnId }).(pulumi.StringPtrOutput) +} + +type OCINodeClassSpecArgsPtrOutput struct{ *pulumi.OutputState } + +func (OCINodeClassSpecArgsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OCINodeClassSpecArgs)(nil)).Elem() +} + +func (o OCINodeClassSpecArgsPtrOutput) ToOCINodeClassSpecArgsPtrOutput() OCINodeClassSpecArgsPtrOutput { + return o +} + +func (o OCINodeClassSpecArgsPtrOutput) ToOCINodeClassSpecArgsPtrOutputWithContext(ctx context.Context) OCINodeClassSpecArgsPtrOutput { + return o +} + +func (o OCINodeClassSpecArgsPtrOutput) Elem() OCINodeClassSpecArgsOutput { + return o.ApplyT(func(v *OCINodeClassSpecArgs) OCINodeClassSpecArgs { + if v != nil { + return *v + } + var ret OCINodeClassSpecArgs + return ret + }).(OCINodeClassSpecArgsOutput) +} + +// OCI compute instance agent plugins to enable. Example: ["Compute Instance Monitoring"]. +func (o OCINodeClassSpecArgsPtrOutput) AgentList() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OCINodeClassSpecArgs) []string { + if v == nil { + return nil + } + return v.AgentList + }).(pulumi.StringArrayOutput) +} + +// Additional block volumes attached to provisioned nodes. +func (o OCINodeClassSpecArgsPtrOutput) BlockDevices() OCIVolumeAttributesArgsArrayOutput { + return o.ApplyT(func(v *OCINodeClassSpecArgs) []OCIVolumeAttributesArgs { + if v == nil { + return nil + } + return v.BlockDevices + }).(OCIVolumeAttributesArgsArrayOutput) +} + +// Boot volume configuration for provisioned nodes. +func (o OCINodeClassSpecArgsPtrOutput) BootConfig() OCIBootConfigArgsPtrOutput { + return o.ApplyT(func(v *OCINodeClassSpecArgs) *OCIBootConfigArgs { + if v == nil { + return nil + } + return v.BootConfig + }).(OCIBootConfigArgsPtrOutput) +} + +// OCI free-form tags applied to all resources created by this node class. Example: {"environment": "production"}. +func (o OCINodeClassSpecArgsPtrOutput) FreeFormTags() pulumi.StringMapOutput { + return o.ApplyT(func(v *OCINodeClassSpecArgs) map[string]string { + if v == nil { + return nil + } + return v.FreeFormTags + }).(pulumi.StringMapOutput) +} + +// OCI node image family shorthand used when no imageSelector is specified. Example: 'Oracle-Linux-8'. +func (o OCINodeClassSpecArgsPtrOutput) ImageFamily() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OCINodeClassSpecArgs) *string { + if v == nil { + return nil + } + return v.ImageFamily + }).(pulumi.StringPtrOutput) +} + +// Selectors for the images used to launch nodes. Example: [{name: "Oracle-Linux-8.9"}]. +func (o OCINodeClassSpecArgsPtrOutput) ImageSelector() OCIImageSelectorTermArgsArrayOutput { + return o.ApplyT(func(v *OCINodeClassSpecArgs) []OCIImageSelectorTermArgs { + if v == nil { + return nil + } + return v.ImageSelector + }).(OCIImageSelectorTermArgsArrayOutput) +} + +// Instance launch options controlling firmware and network/volume emulation type. +func (o OCINodeClassSpecArgsPtrOutput) LaunchOptions() OCILaunchOptionsArgsPtrOutput { + return o.ApplyT(func(v *OCINodeClassSpecArgs) *OCILaunchOptionsArgs { + if v == nil { + return nil + } + return v.LaunchOptions + }).(OCILaunchOptionsArgsPtrOutput) +} + +// OCI instance metadata applied to provisioned nodes. Example: {"ssh_authorized_keys": "ssh-rsa ..."}. +func (o OCINodeClassSpecArgsPtrOutput) MetaData() pulumi.StringMapOutput { + return o.ApplyT(func(v *OCINodeClassSpecArgs) map[string]string { + if v == nil { + return nil + } + return v.MetaData + }).(pulumi.StringMapOutput) +} + +// Script executed before node bootstrap. Example: '#!/bin/bash\necho pre-install'. +func (o OCINodeClassSpecArgsPtrOutput) PreInstallScript() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OCINodeClassSpecArgs) *string { + if v == nil { + return nil + } + return v.PreInstallScript + }).(pulumi.StringPtrOutput) +} + +// Selectors for network security groups attached to provisioned nodes. +func (o OCINodeClassSpecArgsPtrOutput) SecurityGroupSelector() OCISecurityGroupSelectorTermArgsArrayOutput { + return o.ApplyT(func(v *OCINodeClassSpecArgs) []OCISecurityGroupSelectorTermArgs { + if v == nil { + return nil + } + return v.SecurityGroupSelector + }).(OCISecurityGroupSelectorTermArgsArrayOutput) +} + +// Selectors for the subnets nodes will be launched into. +func (o OCINodeClassSpecArgsPtrOutput) SubnetSelector() OCISubnetSelectorTermArgsArrayOutput { + return o.ApplyT(func(v *OCINodeClassSpecArgs) []OCISubnetSelectorTermArgs { + if v == nil { + return nil + } + return v.SubnetSelector + }).(OCISubnetSelectorTermArgsArrayOutput) +} + +// OCI defined tags applied to all resources created by this node class. +func (o OCINodeClassSpecArgsPtrOutput) Tags() pulumi.StringMapOutput { + return o.ApplyT(func(v *OCINodeClassSpecArgs) map[string]string { + if v == nil { + return nil + } + return v.Tags + }).(pulumi.StringMapOutput) +} + +// Custom cloud-init user data merged into the node launch config (base64 or plain text). Example: '#!/bin/bash\necho hello'. +func (o OCINodeClassSpecArgsPtrOutput) UserData() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OCINodeClassSpecArgs) *string { + if v == nil { + return nil + } + return v.UserData + }).(pulumi.StringPtrOutput) +} + +// OCID of the VCN nodes will be launched into. Example: 'ocid1.vcn.oc1..aaaaaaaa'. +func (o OCINodeClassSpecArgsPtrOutput) VcnId() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OCINodeClassSpecArgs) *string { + if v == nil { + return nil + } + return v.VcnId + }).(pulumi.StringPtrOutput) +} + +type OCISecurityGroupSelectorTermArgs struct { + // Explicit OCI network security group OCID. Example: 'ocid1.networksecuritygroup.oc1..aaaaaaaa'. + Id *string `pulumi:"id"` + // OCI network security group display name filter. Example: 'node-nsg'. + Name *string `pulumi:"name"` +} + +// OCISecurityGroupSelectorTermArgsInput is an input type that accepts OCISecurityGroupSelectorTermArgsArgs and OCISecurityGroupSelectorTermArgsOutput values. +// You can construct a concrete instance of `OCISecurityGroupSelectorTermArgsInput` via: +// +// OCISecurityGroupSelectorTermArgsArgs{...} +type OCISecurityGroupSelectorTermArgsInput interface { + pulumi.Input + + ToOCISecurityGroupSelectorTermArgsOutput() OCISecurityGroupSelectorTermArgsOutput + ToOCISecurityGroupSelectorTermArgsOutputWithContext(context.Context) OCISecurityGroupSelectorTermArgsOutput +} + +type OCISecurityGroupSelectorTermArgsArgs struct { + // Explicit OCI network security group OCID. Example: 'ocid1.networksecuritygroup.oc1..aaaaaaaa'. + Id pulumi.StringPtrInput `pulumi:"id"` + // OCI network security group display name filter. Example: 'node-nsg'. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (OCISecurityGroupSelectorTermArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OCISecurityGroupSelectorTermArgs)(nil)).Elem() +} + +func (i OCISecurityGroupSelectorTermArgsArgs) ToOCISecurityGroupSelectorTermArgsOutput() OCISecurityGroupSelectorTermArgsOutput { + return i.ToOCISecurityGroupSelectorTermArgsOutputWithContext(context.Background()) +} + +func (i OCISecurityGroupSelectorTermArgsArgs) ToOCISecurityGroupSelectorTermArgsOutputWithContext(ctx context.Context) OCISecurityGroupSelectorTermArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCISecurityGroupSelectorTermArgsOutput) +} + +// OCISecurityGroupSelectorTermArgsArrayInput is an input type that accepts OCISecurityGroupSelectorTermArgsArray and OCISecurityGroupSelectorTermArgsArrayOutput values. +// You can construct a concrete instance of `OCISecurityGroupSelectorTermArgsArrayInput` via: +// +// OCISecurityGroupSelectorTermArgsArray{ OCISecurityGroupSelectorTermArgsArgs{...} } +type OCISecurityGroupSelectorTermArgsArrayInput interface { + pulumi.Input + + ToOCISecurityGroupSelectorTermArgsArrayOutput() OCISecurityGroupSelectorTermArgsArrayOutput + ToOCISecurityGroupSelectorTermArgsArrayOutputWithContext(context.Context) OCISecurityGroupSelectorTermArgsArrayOutput +} + +type OCISecurityGroupSelectorTermArgsArray []OCISecurityGroupSelectorTermArgsInput + +func (OCISecurityGroupSelectorTermArgsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]OCISecurityGroupSelectorTermArgs)(nil)).Elem() +} + +func (i OCISecurityGroupSelectorTermArgsArray) ToOCISecurityGroupSelectorTermArgsArrayOutput() OCISecurityGroupSelectorTermArgsArrayOutput { + return i.ToOCISecurityGroupSelectorTermArgsArrayOutputWithContext(context.Background()) +} + +func (i OCISecurityGroupSelectorTermArgsArray) ToOCISecurityGroupSelectorTermArgsArrayOutputWithContext(ctx context.Context) OCISecurityGroupSelectorTermArgsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCISecurityGroupSelectorTermArgsArrayOutput) +} + +type OCISecurityGroupSelectorTermArgsOutput struct{ *pulumi.OutputState } + +func (OCISecurityGroupSelectorTermArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OCISecurityGroupSelectorTermArgs)(nil)).Elem() +} + +func (o OCISecurityGroupSelectorTermArgsOutput) ToOCISecurityGroupSelectorTermArgsOutput() OCISecurityGroupSelectorTermArgsOutput { + return o +} + +func (o OCISecurityGroupSelectorTermArgsOutput) ToOCISecurityGroupSelectorTermArgsOutputWithContext(ctx context.Context) OCISecurityGroupSelectorTermArgsOutput { + return o +} + +// Explicit OCI network security group OCID. Example: 'ocid1.networksecuritygroup.oc1..aaaaaaaa'. +func (o OCISecurityGroupSelectorTermArgsOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v OCISecurityGroupSelectorTermArgs) *string { return v.Id }).(pulumi.StringPtrOutput) +} + +// OCI network security group display name filter. Example: 'node-nsg'. +func (o OCISecurityGroupSelectorTermArgsOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v OCISecurityGroupSelectorTermArgs) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +type OCISecurityGroupSelectorTermArgsArrayOutput struct{ *pulumi.OutputState } + +func (OCISecurityGroupSelectorTermArgsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]OCISecurityGroupSelectorTermArgs)(nil)).Elem() +} + +func (o OCISecurityGroupSelectorTermArgsArrayOutput) ToOCISecurityGroupSelectorTermArgsArrayOutput() OCISecurityGroupSelectorTermArgsArrayOutput { + return o +} + +func (o OCISecurityGroupSelectorTermArgsArrayOutput) ToOCISecurityGroupSelectorTermArgsArrayOutputWithContext(ctx context.Context) OCISecurityGroupSelectorTermArgsArrayOutput { + return o +} + +func (o OCISecurityGroupSelectorTermArgsArrayOutput) Index(i pulumi.IntInput) OCISecurityGroupSelectorTermArgsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) OCISecurityGroupSelectorTermArgs { + return vs[0].([]OCISecurityGroupSelectorTermArgs)[vs[1].(int)] + }).(OCISecurityGroupSelectorTermArgsOutput) +} + +type OCISubnetSelectorTermArgs struct { + // Explicit OCI subnet OCID. Example: 'ocid1.subnet.oc1..aaaaaaaa'. + Id *string `pulumi:"id"` + // OCI subnet display name filter. Example: 'node-subnet'. + Name *string `pulumi:"name"` +} + +// OCISubnetSelectorTermArgsInput is an input type that accepts OCISubnetSelectorTermArgsArgs and OCISubnetSelectorTermArgsOutput values. +// You can construct a concrete instance of `OCISubnetSelectorTermArgsInput` via: +// +// OCISubnetSelectorTermArgsArgs{...} +type OCISubnetSelectorTermArgsInput interface { + pulumi.Input + + ToOCISubnetSelectorTermArgsOutput() OCISubnetSelectorTermArgsOutput + ToOCISubnetSelectorTermArgsOutputWithContext(context.Context) OCISubnetSelectorTermArgsOutput +} + +type OCISubnetSelectorTermArgsArgs struct { + // Explicit OCI subnet OCID. Example: 'ocid1.subnet.oc1..aaaaaaaa'. + Id pulumi.StringPtrInput `pulumi:"id"` + // OCI subnet display name filter. Example: 'node-subnet'. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (OCISubnetSelectorTermArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OCISubnetSelectorTermArgs)(nil)).Elem() +} + +func (i OCISubnetSelectorTermArgsArgs) ToOCISubnetSelectorTermArgsOutput() OCISubnetSelectorTermArgsOutput { + return i.ToOCISubnetSelectorTermArgsOutputWithContext(context.Background()) +} + +func (i OCISubnetSelectorTermArgsArgs) ToOCISubnetSelectorTermArgsOutputWithContext(ctx context.Context) OCISubnetSelectorTermArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCISubnetSelectorTermArgsOutput) +} + +// OCISubnetSelectorTermArgsArrayInput is an input type that accepts OCISubnetSelectorTermArgsArray and OCISubnetSelectorTermArgsArrayOutput values. +// You can construct a concrete instance of `OCISubnetSelectorTermArgsArrayInput` via: +// +// OCISubnetSelectorTermArgsArray{ OCISubnetSelectorTermArgsArgs{...} } +type OCISubnetSelectorTermArgsArrayInput interface { + pulumi.Input + + ToOCISubnetSelectorTermArgsArrayOutput() OCISubnetSelectorTermArgsArrayOutput + ToOCISubnetSelectorTermArgsArrayOutputWithContext(context.Context) OCISubnetSelectorTermArgsArrayOutput +} + +type OCISubnetSelectorTermArgsArray []OCISubnetSelectorTermArgsInput + +func (OCISubnetSelectorTermArgsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]OCISubnetSelectorTermArgs)(nil)).Elem() +} + +func (i OCISubnetSelectorTermArgsArray) ToOCISubnetSelectorTermArgsArrayOutput() OCISubnetSelectorTermArgsArrayOutput { + return i.ToOCISubnetSelectorTermArgsArrayOutputWithContext(context.Background()) +} + +func (i OCISubnetSelectorTermArgsArray) ToOCISubnetSelectorTermArgsArrayOutputWithContext(ctx context.Context) OCISubnetSelectorTermArgsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCISubnetSelectorTermArgsArrayOutput) +} + +type OCISubnetSelectorTermArgsOutput struct{ *pulumi.OutputState } + +func (OCISubnetSelectorTermArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OCISubnetSelectorTermArgs)(nil)).Elem() +} + +func (o OCISubnetSelectorTermArgsOutput) ToOCISubnetSelectorTermArgsOutput() OCISubnetSelectorTermArgsOutput { + return o +} + +func (o OCISubnetSelectorTermArgsOutput) ToOCISubnetSelectorTermArgsOutputWithContext(ctx context.Context) OCISubnetSelectorTermArgsOutput { + return o +} + +// Explicit OCI subnet OCID. Example: 'ocid1.subnet.oc1..aaaaaaaa'. +func (o OCISubnetSelectorTermArgsOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v OCISubnetSelectorTermArgs) *string { return v.Id }).(pulumi.StringPtrOutput) +} + +// OCI subnet display name filter. Example: 'node-subnet'. +func (o OCISubnetSelectorTermArgsOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v OCISubnetSelectorTermArgs) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +type OCISubnetSelectorTermArgsArrayOutput struct{ *pulumi.OutputState } + +func (OCISubnetSelectorTermArgsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]OCISubnetSelectorTermArgs)(nil)).Elem() +} + +func (o OCISubnetSelectorTermArgsArrayOutput) ToOCISubnetSelectorTermArgsArrayOutput() OCISubnetSelectorTermArgsArrayOutput { + return o +} + +func (o OCISubnetSelectorTermArgsArrayOutput) ToOCISubnetSelectorTermArgsArrayOutputWithContext(ctx context.Context) OCISubnetSelectorTermArgsArrayOutput { + return o +} + +func (o OCISubnetSelectorTermArgsArrayOutput) Index(i pulumi.IntInput) OCISubnetSelectorTermArgsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) OCISubnetSelectorTermArgs { + return vs[0].([]OCISubnetSelectorTermArgs)[vs[1].(int)] + }).(OCISubnetSelectorTermArgsOutput) +} + +type OCIVolumeAttributesArgs struct { + // Block volume size in GB. Example: 50. + SizeInGbs *int `pulumi:"sizeInGbs"` + // Block volume performance units per GB. Example: 10. + VpusPerGb *int `pulumi:"vpusPerGb"` +} + +// OCIVolumeAttributesArgsInput is an input type that accepts OCIVolumeAttributesArgsArgs and OCIVolumeAttributesArgsOutput values. +// You can construct a concrete instance of `OCIVolumeAttributesArgsInput` via: +// +// OCIVolumeAttributesArgsArgs{...} +type OCIVolumeAttributesArgsInput interface { + pulumi.Input + + ToOCIVolumeAttributesArgsOutput() OCIVolumeAttributesArgsOutput + ToOCIVolumeAttributesArgsOutputWithContext(context.Context) OCIVolumeAttributesArgsOutput +} + +type OCIVolumeAttributesArgsArgs struct { + // Block volume size in GB. Example: 50. + SizeInGbs pulumi.IntPtrInput `pulumi:"sizeInGbs"` + // Block volume performance units per GB. Example: 10. + VpusPerGb pulumi.IntPtrInput `pulumi:"vpusPerGb"` +} + +func (OCIVolumeAttributesArgsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OCIVolumeAttributesArgs)(nil)).Elem() +} + +func (i OCIVolumeAttributesArgsArgs) ToOCIVolumeAttributesArgsOutput() OCIVolumeAttributesArgsOutput { + return i.ToOCIVolumeAttributesArgsOutputWithContext(context.Background()) +} + +func (i OCIVolumeAttributesArgsArgs) ToOCIVolumeAttributesArgsOutputWithContext(ctx context.Context) OCIVolumeAttributesArgsOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCIVolumeAttributesArgsOutput) +} + +// OCIVolumeAttributesArgsArrayInput is an input type that accepts OCIVolumeAttributesArgsArray and OCIVolumeAttributesArgsArrayOutput values. +// You can construct a concrete instance of `OCIVolumeAttributesArgsArrayInput` via: +// +// OCIVolumeAttributesArgsArray{ OCIVolumeAttributesArgsArgs{...} } +type OCIVolumeAttributesArgsArrayInput interface { + pulumi.Input + + ToOCIVolumeAttributesArgsArrayOutput() OCIVolumeAttributesArgsArrayOutput + ToOCIVolumeAttributesArgsArrayOutputWithContext(context.Context) OCIVolumeAttributesArgsArrayOutput +} + +type OCIVolumeAttributesArgsArray []OCIVolumeAttributesArgsInput + +func (OCIVolumeAttributesArgsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]OCIVolumeAttributesArgs)(nil)).Elem() +} + +func (i OCIVolumeAttributesArgsArray) ToOCIVolumeAttributesArgsArrayOutput() OCIVolumeAttributesArgsArrayOutput { + return i.ToOCIVolumeAttributesArgsArrayOutputWithContext(context.Background()) +} + +func (i OCIVolumeAttributesArgsArray) ToOCIVolumeAttributesArgsArrayOutputWithContext(ctx context.Context) OCIVolumeAttributesArgsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OCIVolumeAttributesArgsArrayOutput) +} + +type OCIVolumeAttributesArgsOutput struct{ *pulumi.OutputState } + +func (OCIVolumeAttributesArgsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OCIVolumeAttributesArgs)(nil)).Elem() +} + +func (o OCIVolumeAttributesArgsOutput) ToOCIVolumeAttributesArgsOutput() OCIVolumeAttributesArgsOutput { + return o +} + +func (o OCIVolumeAttributesArgsOutput) ToOCIVolumeAttributesArgsOutputWithContext(ctx context.Context) OCIVolumeAttributesArgsOutput { + return o +} + +// Block volume size in GB. Example: 50. +func (o OCIVolumeAttributesArgsOutput) SizeInGbs() pulumi.IntPtrOutput { + return o.ApplyT(func(v OCIVolumeAttributesArgs) *int { return v.SizeInGbs }).(pulumi.IntPtrOutput) +} + +// Block volume performance units per GB. Example: 10. +func (o OCIVolumeAttributesArgsOutput) VpusPerGb() pulumi.IntPtrOutput { + return o.ApplyT(func(v OCIVolumeAttributesArgs) *int { return v.VpusPerGb }).(pulumi.IntPtrOutput) +} + +type OCIVolumeAttributesArgsArrayOutput struct{ *pulumi.OutputState } + +func (OCIVolumeAttributesArgsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]OCIVolumeAttributesArgs)(nil)).Elem() +} + +func (o OCIVolumeAttributesArgsArrayOutput) ToOCIVolumeAttributesArgsArrayOutput() OCIVolumeAttributesArgsArrayOutput { + return o +} + +func (o OCIVolumeAttributesArgsArrayOutput) ToOCIVolumeAttributesArgsArrayOutputWithContext(ctx context.Context) OCIVolumeAttributesArgsArrayOutput { + return o +} + +func (o OCIVolumeAttributesArgsArrayOutput) Index(i pulumi.IntInput) OCIVolumeAttributesArgsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) OCIVolumeAttributesArgs { + return vs[0].([]OCIVolumeAttributesArgs)[vs[1].(int)] + }).(OCIVolumeAttributesArgsOutput) } type RawKarpenterSpecArgs struct { @@ -6355,6 +9238,12 @@ func init() { pulumi.RegisterInputType(reflect.TypeOf((*DisruptionPolicyArgsPtrInput)(nil)).Elem(), DisruptionPolicyArgsArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*EmergencyResponseConfigArgsInput)(nil)).Elem(), EmergencyResponseConfigArgsArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*EmergencyResponseConfigArgsPtrInput)(nil)).Elem(), EmergencyResponseConfigArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GCPDiskArgsInput)(nil)).Elem(), GCPDiskArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GCPDiskArgsArrayInput)(nil)).Elem(), GCPDiskArgsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GCPImageSelectorTermArgsInput)(nil)).Elem(), GCPImageSelectorTermArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GCPImageSelectorTermArgsArrayInput)(nil)).Elem(), GCPImageSelectorTermArgsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GCPNodeClassSpecArgsInput)(nil)).Elem(), GCPNodeClassSpecArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GCPNodeClassSpecArgsPtrInput)(nil)).Elem(), GCPNodeClassSpecArgsArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*HPABehaviorArgsInput)(nil)).Elem(), HPABehaviorArgsArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*HPABehaviorArgsPtrInput)(nil)).Elem(), HPABehaviorArgsArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*HPAFallbackArgsInput)(nil)).Elem(), HPAFallbackArgsArgs{}) @@ -6369,6 +9258,18 @@ func init() { pulumi.RegisterInputType(reflect.TypeOf((*HPAScalingRulesArgsPtrInput)(nil)).Elem(), HPAScalingRulesArgsArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*HorizontalScalingArgsInput)(nil)).Elem(), HorizontalScalingArgsArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*HorizontalScalingArgsPtrInput)(nil)).Elem(), HorizontalScalingArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*JvmHeapRuleConfigArgsInput)(nil)).Elem(), JvmHeapRuleConfigArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*JvmHeapRuleConfigArgsPtrInput)(nil)).Elem(), JvmHeapRuleConfigArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KedaAdvancedArgsInput)(nil)).Elem(), KedaAdvancedArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KedaAdvancedArgsPtrInput)(nil)).Elem(), KedaAdvancedArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KedaAuthenticationRefArgsInput)(nil)).Elem(), KedaAuthenticationRefArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KedaAuthenticationRefArgsPtrInput)(nil)).Elem(), KedaAuthenticationRefArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KedaFallbackArgsInput)(nil)).Elem(), KedaFallbackArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KedaFallbackArgsPtrInput)(nil)).Elem(), KedaFallbackArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KedaScaledObjectArgsInput)(nil)).Elem(), KedaScaledObjectArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KedaScaledObjectArgsPtrInput)(nil)).Elem(), KedaScaledObjectArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KedaTriggerArgsInput)(nil)).Elem(), KedaTriggerArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KedaTriggerArgsArrayInput)(nil)).Elem(), KedaTriggerArgsArray{}) pulumi.RegisterInputType(reflect.TypeOf((*KubeletConfigurationArgsInput)(nil)).Elem(), KubeletConfigurationArgsArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*KubeletConfigurationArgsPtrInput)(nil)).Elem(), KubeletConfigurationArgsArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*LabelSelectorArgsInput)(nil)).Elem(), LabelSelectorArgsArgs{}) @@ -6379,6 +9280,20 @@ func init() { pulumi.RegisterInputType(reflect.TypeOf((*MetadataOptionsArgsPtrInput)(nil)).Elem(), MetadataOptionsArgsArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*NamePatternArgsInput)(nil)).Elem(), NamePatternArgsArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*NamePatternArgsPtrInput)(nil)).Elem(), NamePatternArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OCIBootConfigArgsInput)(nil)).Elem(), OCIBootConfigArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OCIBootConfigArgsPtrInput)(nil)).Elem(), OCIBootConfigArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OCIImageSelectorTermArgsInput)(nil)).Elem(), OCIImageSelectorTermArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OCIImageSelectorTermArgsArrayInput)(nil)).Elem(), OCIImageSelectorTermArgsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OCILaunchOptionsArgsInput)(nil)).Elem(), OCILaunchOptionsArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OCILaunchOptionsArgsPtrInput)(nil)).Elem(), OCILaunchOptionsArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OCINodeClassSpecArgsInput)(nil)).Elem(), OCINodeClassSpecArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OCINodeClassSpecArgsPtrInput)(nil)).Elem(), OCINodeClassSpecArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OCISecurityGroupSelectorTermArgsInput)(nil)).Elem(), OCISecurityGroupSelectorTermArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OCISecurityGroupSelectorTermArgsArrayInput)(nil)).Elem(), OCISecurityGroupSelectorTermArgsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OCISubnetSelectorTermArgsInput)(nil)).Elem(), OCISubnetSelectorTermArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OCISubnetSelectorTermArgsArrayInput)(nil)).Elem(), OCISubnetSelectorTermArgsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OCIVolumeAttributesArgsInput)(nil)).Elem(), OCIVolumeAttributesArgsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OCIVolumeAttributesArgsArrayInput)(nil)).Elem(), OCIVolumeAttributesArgsArray{}) pulumi.RegisterInputType(reflect.TypeOf((*RawKarpenterSpecArgsInput)(nil)).Elem(), RawKarpenterSpecArgsArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*RawKarpenterSpecArgsArrayInput)(nil)).Elem(), RawKarpenterSpecArgsArray{}) pulumi.RegisterInputType(reflect.TypeOf((*ResourceLimitsArgsInput)(nil)).Elem(), ResourceLimitsArgsArgs{}) @@ -6417,6 +9332,12 @@ func init() { pulumi.RegisterOutputType(DisruptionPolicyArgsPtrOutput{}) pulumi.RegisterOutputType(EmergencyResponseConfigArgsOutput{}) pulumi.RegisterOutputType(EmergencyResponseConfigArgsPtrOutput{}) + pulumi.RegisterOutputType(GCPDiskArgsOutput{}) + pulumi.RegisterOutputType(GCPDiskArgsArrayOutput{}) + pulumi.RegisterOutputType(GCPImageSelectorTermArgsOutput{}) + pulumi.RegisterOutputType(GCPImageSelectorTermArgsArrayOutput{}) + pulumi.RegisterOutputType(GCPNodeClassSpecArgsOutput{}) + pulumi.RegisterOutputType(GCPNodeClassSpecArgsPtrOutput{}) pulumi.RegisterOutputType(HPABehaviorArgsOutput{}) pulumi.RegisterOutputType(HPABehaviorArgsPtrOutput{}) pulumi.RegisterOutputType(HPAFallbackArgsOutput{}) @@ -6431,6 +9352,18 @@ func init() { pulumi.RegisterOutputType(HPAScalingRulesArgsPtrOutput{}) pulumi.RegisterOutputType(HorizontalScalingArgsOutput{}) pulumi.RegisterOutputType(HorizontalScalingArgsPtrOutput{}) + pulumi.RegisterOutputType(JvmHeapRuleConfigArgsOutput{}) + pulumi.RegisterOutputType(JvmHeapRuleConfigArgsPtrOutput{}) + pulumi.RegisterOutputType(KedaAdvancedArgsOutput{}) + pulumi.RegisterOutputType(KedaAdvancedArgsPtrOutput{}) + pulumi.RegisterOutputType(KedaAuthenticationRefArgsOutput{}) + pulumi.RegisterOutputType(KedaAuthenticationRefArgsPtrOutput{}) + pulumi.RegisterOutputType(KedaFallbackArgsOutput{}) + pulumi.RegisterOutputType(KedaFallbackArgsPtrOutput{}) + pulumi.RegisterOutputType(KedaScaledObjectArgsOutput{}) + pulumi.RegisterOutputType(KedaScaledObjectArgsPtrOutput{}) + pulumi.RegisterOutputType(KedaTriggerArgsOutput{}) + pulumi.RegisterOutputType(KedaTriggerArgsArrayOutput{}) pulumi.RegisterOutputType(KubeletConfigurationArgsOutput{}) pulumi.RegisterOutputType(KubeletConfigurationArgsPtrOutput{}) pulumi.RegisterOutputType(LabelSelectorArgsOutput{}) @@ -6441,6 +9374,20 @@ func init() { pulumi.RegisterOutputType(MetadataOptionsArgsPtrOutput{}) pulumi.RegisterOutputType(NamePatternArgsOutput{}) pulumi.RegisterOutputType(NamePatternArgsPtrOutput{}) + pulumi.RegisterOutputType(OCIBootConfigArgsOutput{}) + pulumi.RegisterOutputType(OCIBootConfigArgsPtrOutput{}) + pulumi.RegisterOutputType(OCIImageSelectorTermArgsOutput{}) + pulumi.RegisterOutputType(OCIImageSelectorTermArgsArrayOutput{}) + pulumi.RegisterOutputType(OCILaunchOptionsArgsOutput{}) + pulumi.RegisterOutputType(OCILaunchOptionsArgsPtrOutput{}) + pulumi.RegisterOutputType(OCINodeClassSpecArgsOutput{}) + pulumi.RegisterOutputType(OCINodeClassSpecArgsPtrOutput{}) + pulumi.RegisterOutputType(OCISecurityGroupSelectorTermArgsOutput{}) + pulumi.RegisterOutputType(OCISecurityGroupSelectorTermArgsArrayOutput{}) + pulumi.RegisterOutputType(OCISubnetSelectorTermArgsOutput{}) + pulumi.RegisterOutputType(OCISubnetSelectorTermArgsArrayOutput{}) + pulumi.RegisterOutputType(OCIVolumeAttributesArgsOutput{}) + pulumi.RegisterOutputType(OCIVolumeAttributesArgsArrayOutput{}) pulumi.RegisterOutputType(RawKarpenterSpecArgsOutput{}) pulumi.RegisterOutputType(RawKarpenterSpecArgsArrayOutput{}) pulumi.RegisterOutputType(ResourceLimitsArgsOutput{}) diff --git a/sdk/go/devzero/resources/workloadPolicy.go b/sdk/go/devzero/resources/workloadPolicy.go index c429865..65b3db6 100644 --- a/sdk/go/devzero/resources/workloadPolicy.go +++ b/sdk/go/devzero/resources/workloadPolicy.go @@ -34,8 +34,10 @@ type WorkloadPolicy struct { // Events that trigger a new recommendation. Valid values: 'pod_creation', 'pod_update', 'pod_reschedule'. Example: ["pod_creation", "pod_reschedule"]. DetectionTriggers pulumi.StringArrayOutput `pulumi:"detectionTriggers"` // Percentage change from the baseline recommendation that triggers a VPA refresh. Example: 20.0. - DriftDeltaPercent pulumi.Float64PtrOutput `pulumi:"driftDeltaPercent"` - EnableInPlaceVerticalScaling pulumi.BoolPtrOutput `pulumi:"enableInPlaceVerticalScaling"` + DriftDeltaPercent pulumi.Float64PtrOutput `pulumi:"driftDeltaPercent"` + // Emergency response configuration for OOM and CPU throttle events. + EmergencyResponse EmergencyResponseConfigArgsPtrOutput `pulumi:"emergencyResponse"` + EnableInPlaceVerticalScaling pulumi.BoolPtrOutput `pulumi:"enableInPlaceVerticalScaling"` // Raise requests to cover observed peak usage when the peak/recommendation ratio exceeds pmaxRatioThreshold. Default: false. EnablePmaxProtection pulumi.BoolPtrOutput `pulumi:"enablePmaxProtection"` // Vertical scaling configuration for GPU cores. Uses the same fields as cpuVerticalScaling; units are GPU cores (millicores). @@ -174,8 +176,10 @@ type workloadPolicyArgs struct { // Events that trigger a new recommendation. Valid values: 'pod_creation', 'pod_update', 'pod_reschedule'. Example: ["pod_creation", "pod_reschedule"]. DetectionTriggers []string `pulumi:"detectionTriggers"` // Percentage change from the baseline recommendation that triggers a VPA refresh. Example: 20.0. - DriftDeltaPercent *float64 `pulumi:"driftDeltaPercent"` - EnableInPlaceVerticalScaling *bool `pulumi:"enableInPlaceVerticalScaling"` + DriftDeltaPercent *float64 `pulumi:"driftDeltaPercent"` + // Emergency response configuration for OOM and CPU throttle events. + EmergencyResponse *EmergencyResponseConfigArgs `pulumi:"emergencyResponse"` + EnableInPlaceVerticalScaling *bool `pulumi:"enableInPlaceVerticalScaling"` // Raise requests to cover observed peak usage when the peak/recommendation ratio exceeds pmaxRatioThreshold. Default: false. EnablePmaxProtection *bool `pulumi:"enablePmaxProtection"` // Vertical scaling configuration for GPU cores. Uses the same fields as cpuVerticalScaling; units are GPU cores (millicores). @@ -243,7 +247,9 @@ type WorkloadPolicyArgs struct { // Events that trigger a new recommendation. Valid values: 'pod_creation', 'pod_update', 'pod_reschedule'. Example: ["pod_creation", "pod_reschedule"]. DetectionTriggers pulumi.StringArrayInput // Percentage change from the baseline recommendation that triggers a VPA refresh. Example: 20.0. - DriftDeltaPercent pulumi.Float64PtrInput + DriftDeltaPercent pulumi.Float64PtrInput + // Emergency response configuration for OOM and CPU throttle events. + EmergencyResponse EmergencyResponseConfigArgsPtrInput EnableInPlaceVerticalScaling pulumi.BoolPtrInput // Raise requests to cover observed peak usage when the peak/recommendation ratio exceeds pmaxRatioThreshold. Default: false. EnablePmaxProtection pulumi.BoolPtrInput @@ -437,6 +443,11 @@ func (o WorkloadPolicyOutput) DriftDeltaPercent() pulumi.Float64PtrOutput { return o.ApplyT(func(v *WorkloadPolicy) pulumi.Float64PtrOutput { return v.DriftDeltaPercent }).(pulumi.Float64PtrOutput) } +// Emergency response configuration for OOM and CPU throttle events. +func (o WorkloadPolicyOutput) EmergencyResponse() EmergencyResponseConfigArgsPtrOutput { + return o.ApplyT(func(v *WorkloadPolicy) EmergencyResponseConfigArgsPtrOutput { return v.EmergencyResponse }).(EmergencyResponseConfigArgsPtrOutput) +} + func (o WorkloadPolicyOutput) EnableInPlaceVerticalScaling() pulumi.BoolPtrOutput { return o.ApplyT(func(v *WorkloadPolicy) pulumi.BoolPtrOutput { return v.EnableInPlaceVerticalScaling }).(pulumi.BoolPtrOutput) } diff --git a/sdk/go/devzero/resources/workloadRule.go b/sdk/go/devzero/resources/workloadRule.go index 9404561..cb3bbf4 100644 --- a/sdk/go/devzero/resources/workloadRule.go +++ b/sdk/go/devzero/resources/workloadRule.go @@ -17,6 +17,8 @@ type WorkloadRule struct { // When to apply recommendations. Valid values: 'on_detection', 'on_schedule'. Example: ["on_detection"]. ActionTriggers pulumi.StringArrayOutput `pulumi:"actionTriggers"` + // Allow in-place vertical scaling to decrease the memory limit (normally only requests shrink; limits only grow). Example: false. + AllowInPlaceMemoryLimitDecrease pulumi.BoolPtrOutput `pulumi:"allowInPlaceMemoryLimitDecrease"` // When true the engine generates all rule fields automatically; manual field overrides are ignored. Example: false. AutoGenerate pulumi.BoolPtrOutput `pulumi:"autoGenerate"` // ID of the cluster this rule targets. Example: 'cluster-abc123'. @@ -40,6 +42,12 @@ type WorkloadRule struct { GpuRule ResourceRuleConfigArgsPtrOutput `pulumi:"gpuRule"` // Horizontal (replica) scaling rule configuration. HpaRule HPARuleConfigArgsPtrOutput `pulumi:"hpaRule"` + // Minimum CPU request in millicores during JVM startup, to avoid slow JIT warmup on undersized CPU. Example: 500. + JvmCpuStartupFloorMillicores pulumi.IntPtrOutput `pulumi:"jvmCpuStartupFloorMillicores"` + // JVM heap sizing overrides applied to detected Java containers. + JvmHeapRule JvmHeapRuleConfigArgsPtrOutput `pulumi:"jvmHeapRule"` + // KEDA ScaledObject configuration managed alongside this workload. + KedaScaledObject KedaScaledObjectArgsPtrOutput `pulumi:"kedaScaledObject"` // Kubernetes workload kind. One of: 'Deployment', 'StatefulSet', 'DaemonSet', 'CronJob', 'Job'. Example: 'Deployment'. Kind pulumi.StringOutput `pulumi:"kind"` // Allow live pod migration when applying recommendations. Example: false. @@ -113,6 +121,8 @@ func (WorkloadRuleState) ElementType() reflect.Type { type workloadRuleArgs struct { // When to apply recommendations. Valid values: 'on_detection', 'on_schedule'. Example: ["on_detection"]. ActionTriggers []string `pulumi:"actionTriggers"` + // Allow in-place vertical scaling to decrease the memory limit (normally only requests shrink; limits only grow). Example: false. + AllowInPlaceMemoryLimitDecrease *bool `pulumi:"allowInPlaceMemoryLimitDecrease"` // When true the engine generates all rule fields automatically; manual field overrides are ignored. Example: false. AutoGenerate *bool `pulumi:"autoGenerate"` // ID of the cluster this rule targets. Example: 'cluster-abc123'. @@ -136,6 +146,12 @@ type workloadRuleArgs struct { GpuRule *ResourceRuleConfigArgs `pulumi:"gpuRule"` // Horizontal (replica) scaling rule configuration. HpaRule *HPARuleConfigArgs `pulumi:"hpaRule"` + // Minimum CPU request in millicores during JVM startup, to avoid slow JIT warmup on undersized CPU. Example: 500. + JvmCpuStartupFloorMillicores *int `pulumi:"jvmCpuStartupFloorMillicores"` + // JVM heap sizing overrides applied to detected Java containers. + JvmHeapRule *JvmHeapRuleConfigArgs `pulumi:"jvmHeapRule"` + // KEDA ScaledObject configuration managed alongside this workload. + KedaScaledObject *KedaScaledObjectArgs `pulumi:"kedaScaledObject"` // Kubernetes workload kind. One of: 'Deployment', 'StatefulSet', 'DaemonSet', 'CronJob', 'Job'. Example: 'Deployment'. Kind string `pulumi:"kind"` // Allow live pod migration when applying recommendations. Example: false. @@ -159,6 +175,8 @@ type workloadRuleArgs struct { type WorkloadRuleArgs struct { // When to apply recommendations. Valid values: 'on_detection', 'on_schedule'. Example: ["on_detection"]. ActionTriggers pulumi.StringArrayInput + // Allow in-place vertical scaling to decrease the memory limit (normally only requests shrink; limits only grow). Example: false. + AllowInPlaceMemoryLimitDecrease pulumi.BoolPtrInput // When true the engine generates all rule fields automatically; manual field overrides are ignored. Example: false. AutoGenerate pulumi.BoolPtrInput // ID of the cluster this rule targets. Example: 'cluster-abc123'. @@ -182,6 +200,12 @@ type WorkloadRuleArgs struct { GpuRule ResourceRuleConfigArgsPtrInput // Horizontal (replica) scaling rule configuration. HpaRule HPARuleConfigArgsPtrInput + // Minimum CPU request in millicores during JVM startup, to avoid slow JIT warmup on undersized CPU. Example: 500. + JvmCpuStartupFloorMillicores pulumi.IntPtrInput + // JVM heap sizing overrides applied to detected Java containers. + JvmHeapRule JvmHeapRuleConfigArgsPtrInput + // KEDA ScaledObject configuration managed alongside this workload. + KedaScaledObject KedaScaledObjectArgsPtrInput // Kubernetes workload kind. One of: 'Deployment', 'StatefulSet', 'DaemonSet', 'CronJob', 'Job'. Example: 'Deployment'. Kind pulumi.StringInput // Allow live pod migration when applying recommendations. Example: false. @@ -293,6 +317,11 @@ func (o WorkloadRuleOutput) ActionTriggers() pulumi.StringArrayOutput { return o.ApplyT(func(v *WorkloadRule) pulumi.StringArrayOutput { return v.ActionTriggers }).(pulumi.StringArrayOutput) } +// Allow in-place vertical scaling to decrease the memory limit (normally only requests shrink; limits only grow). Example: false. +func (o WorkloadRuleOutput) AllowInPlaceMemoryLimitDecrease() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *WorkloadRule) pulumi.BoolPtrOutput { return v.AllowInPlaceMemoryLimitDecrease }).(pulumi.BoolPtrOutput) +} + // When true the engine generates all rule fields automatically; manual field overrides are ignored. Example: false. func (o WorkloadRuleOutput) AutoGenerate() pulumi.BoolPtrOutput { return o.ApplyT(func(v *WorkloadRule) pulumi.BoolPtrOutput { return v.AutoGenerate }).(pulumi.BoolPtrOutput) @@ -352,6 +381,21 @@ func (o WorkloadRuleOutput) HpaRule() HPARuleConfigArgsPtrOutput { return o.ApplyT(func(v *WorkloadRule) HPARuleConfigArgsPtrOutput { return v.HpaRule }).(HPARuleConfigArgsPtrOutput) } +// Minimum CPU request in millicores during JVM startup, to avoid slow JIT warmup on undersized CPU. Example: 500. +func (o WorkloadRuleOutput) JvmCpuStartupFloorMillicores() pulumi.IntPtrOutput { + return o.ApplyT(func(v *WorkloadRule) pulumi.IntPtrOutput { return v.JvmCpuStartupFloorMillicores }).(pulumi.IntPtrOutput) +} + +// JVM heap sizing overrides applied to detected Java containers. +func (o WorkloadRuleOutput) JvmHeapRule() JvmHeapRuleConfigArgsPtrOutput { + return o.ApplyT(func(v *WorkloadRule) JvmHeapRuleConfigArgsPtrOutput { return v.JvmHeapRule }).(JvmHeapRuleConfigArgsPtrOutput) +} + +// KEDA ScaledObject configuration managed alongside this workload. +func (o WorkloadRuleOutput) KedaScaledObject() KedaScaledObjectArgsPtrOutput { + return o.ApplyT(func(v *WorkloadRule) KedaScaledObjectArgsPtrOutput { return v.KedaScaledObject }).(KedaScaledObjectArgsPtrOutput) +} + // Kubernetes workload kind. One of: 'Deployment', 'StatefulSet', 'DaemonSet', 'CronJob', 'Job'. Example: 'Deployment'. func (o WorkloadRuleOutput) Kind() pulumi.StringOutput { return o.ApplyT(func(v *WorkloadRule) pulumi.StringOutput { return v.Kind }).(pulumi.StringOutput) diff --git a/sdk/nodejs/resources/cluster.ts b/sdk/nodejs/resources/cluster.ts index c8fd8da..fde7d46 100644 --- a/sdk/nodejs/resources/cluster.ts +++ b/sdk/nodejs/resources/cluster.ts @@ -36,7 +36,7 @@ export class Cluster extends pulumi.CustomResource { */ declare public readonly name: pulumi.Output; /** - * Authentication token for the cluster. Rotated automatically if empty on update (e.g. after import). + * Bearer token minted for the cluster at creation. Not retrievable afterwards; imported clusters have an empty token (rotate it deliberately from the DevZero UI if you need it in state). */ declare public /*out*/ readonly token: pulumi.Output; diff --git a/sdk/nodejs/resources/nodePolicy.ts b/sdk/nodejs/resources/nodePolicy.ts index ece94f2..50626ea 100644 --- a/sdk/nodejs/resources/nodePolicy.ts +++ b/sdk/nodejs/resources/nodePolicy.ts @@ -58,6 +58,10 @@ export class NodePolicy extends pulumi.CustomResource { * Karpenter disruption policy controlling consolidation, expiry, and budgets. */ declare public readonly disruption: pulumi.Output; + /** + * GCP-specific GCENodeClass configuration (service account, images, disks, etc.). + */ + declare public readonly gcp: pulumi.Output; /** * Filter instances by category letter (cloud-specific). Example: {in: ["m", "c", "r"]} for AWS, {in: ["D", "E"]} for Azure. */ @@ -79,6 +83,18 @@ export class NodePolicy extends pulumi.CustomResource { */ declare public readonly instanceHypervisors: pulumi.Output; declare public readonly instanceLocalNvme: pulumi.Output; + /** + * UI tooltip text shown alongside the instanceLocalNvme selector. + */ + declare public readonly instanceLocalNvmeTip: pulumi.Output; + /** + * GCP-only: filter by standard/highcpu/highmem custom shape token. Example: {in: ["standard", "highmem"]}. + */ + declare public readonly instanceShapes: pulumi.Output; + /** + * UI tooltip text shown alongside the instanceShapes selector. + */ + declare public readonly instanceShapesTip: pulumi.Output; /** * Filter instances by size label. Example: {in: ["large", "xlarge", "2xlarge"]}. */ @@ -108,6 +124,10 @@ export class NodePolicy extends pulumi.CustomResource { * Override name for the generated Karpenter NodePool resource. Example: 'prod-spot-nodepool'. */ declare public readonly nodePoolName: pulumi.Output; + /** + * OCI-specific NodeClass configuration (VCN, subnets, images, block volumes, etc.). + */ + declare public readonly oci: pulumi.Output; /** * Operating systems for nodes. Example: {in: ["linux"]}. */ @@ -117,6 +137,10 @@ export class NodePolicy extends pulumi.CustomResource { */ declare public readonly raw: pulumi.Output; declare public readonly startupTaints: pulumi.Output; + /** + * UI tooltip text shown alongside startupTaints. + */ + declare public readonly startupTaintsTip: pulumi.Output; /** * Taints applied to provisioned nodes to control pod scheduling. Example: [{key: "dedicated", value: "gpu", effect: "NoSchedule"}]. */ @@ -152,12 +176,16 @@ export class NodePolicy extends pulumi.CustomResource { resourceInputs["cloudProviderId"] = args?.cloudProviderId; resourceInputs["description"] = args?.description; resourceInputs["disruption"] = args?.disruption; + resourceInputs["gcp"] = args?.gcp; resourceInputs["instanceCategories"] = args?.instanceCategories; resourceInputs["instanceCpus"] = args?.instanceCpus; resourceInputs["instanceFamilies"] = args?.instanceFamilies; resourceInputs["instanceGenerations"] = args?.instanceGenerations; resourceInputs["instanceHypervisors"] = args?.instanceHypervisors; resourceInputs["instanceLocalNvme"] = args?.instanceLocalNvme; + resourceInputs["instanceLocalNvmeTip"] = args?.instanceLocalNvmeTip; + resourceInputs["instanceShapes"] = args?.instanceShapes; + resourceInputs["instanceShapesTip"] = args?.instanceShapesTip; resourceInputs["instanceSizes"] = args?.instanceSizes; resourceInputs["instanceTypes"] = args?.instanceTypes; resourceInputs["labels"] = args?.labels; @@ -166,9 +194,11 @@ export class NodePolicy extends pulumi.CustomResource { resourceInputs["name"] = args?.name; resourceInputs["nodeClassName"] = args?.nodeClassName; resourceInputs["nodePoolName"] = args?.nodePoolName; + resourceInputs["oci"] = args?.oci; resourceInputs["operatingSystems"] = args?.operatingSystems; resourceInputs["raw"] = args?.raw; resourceInputs["startupTaints"] = args?.startupTaints; + resourceInputs["startupTaintsTip"] = args?.startupTaintsTip; resourceInputs["taints"] = args?.taints; resourceInputs["weight"] = args?.weight; resourceInputs["zonalShift"] = args?.zonalShift; @@ -181,12 +211,16 @@ export class NodePolicy extends pulumi.CustomResource { resourceInputs["cloudProviderId"] = undefined /*out*/; resourceInputs["description"] = undefined /*out*/; resourceInputs["disruption"] = undefined /*out*/; + resourceInputs["gcp"] = undefined /*out*/; resourceInputs["instanceCategories"] = undefined /*out*/; resourceInputs["instanceCpus"] = undefined /*out*/; resourceInputs["instanceFamilies"] = undefined /*out*/; resourceInputs["instanceGenerations"] = undefined /*out*/; resourceInputs["instanceHypervisors"] = undefined /*out*/; resourceInputs["instanceLocalNvme"] = undefined /*out*/; + resourceInputs["instanceLocalNvmeTip"] = undefined /*out*/; + resourceInputs["instanceShapes"] = undefined /*out*/; + resourceInputs["instanceShapesTip"] = undefined /*out*/; resourceInputs["instanceSizes"] = undefined /*out*/; resourceInputs["instanceTypes"] = undefined /*out*/; resourceInputs["labels"] = undefined /*out*/; @@ -195,9 +229,11 @@ export class NodePolicy extends pulumi.CustomResource { resourceInputs["name"] = undefined /*out*/; resourceInputs["nodeClassName"] = undefined /*out*/; resourceInputs["nodePoolName"] = undefined /*out*/; + resourceInputs["oci"] = undefined /*out*/; resourceInputs["operatingSystems"] = undefined /*out*/; resourceInputs["raw"] = undefined /*out*/; resourceInputs["startupTaints"] = undefined /*out*/; + resourceInputs["startupTaintsTip"] = undefined /*out*/; resourceInputs["taints"] = undefined /*out*/; resourceInputs["weight"] = undefined /*out*/; resourceInputs["zonalShift"] = undefined /*out*/; @@ -219,12 +255,16 @@ export interface NodePolicyArgs { cloudProviderId?: pulumi.Input; description?: pulumi.Input; disruption?: pulumi.Input; + gcp?: pulumi.Input; instanceCategories?: pulumi.Input; instanceCpus?: pulumi.Input; instanceFamilies?: pulumi.Input; instanceGenerations?: pulumi.Input; instanceHypervisors?: pulumi.Input; instanceLocalNvme?: pulumi.Input; + instanceLocalNvmeTip?: pulumi.Input; + instanceShapes?: pulumi.Input; + instanceShapesTip?: pulumi.Input; instanceSizes?: pulumi.Input; instanceTypes?: pulumi.Input; labels?: pulumi.Input<{[key: string]: pulumi.Input}>; @@ -233,9 +273,11 @@ export interface NodePolicyArgs { name: pulumi.Input; nodeClassName?: pulumi.Input; nodePoolName?: pulumi.Input; + oci?: pulumi.Input; operatingSystems?: pulumi.Input; raw?: pulumi.Input[]>; startupTaints?: pulumi.Input[]>; + startupTaintsTip?: pulumi.Input; taints?: pulumi.Input[]>; weight?: pulumi.Input; zonalShift?: pulumi.Input; diff --git a/sdk/nodejs/resources/workloadPolicy.ts b/sdk/nodejs/resources/workloadPolicy.ts index 1a3cf33..5ac6452 100644 --- a/sdk/nodejs/resources/workloadPolicy.ts +++ b/sdk/nodejs/resources/workloadPolicy.ts @@ -67,6 +67,10 @@ export class WorkloadPolicy extends pulumi.CustomResource { * Percentage change from the baseline recommendation that triggers a VPA refresh. Example: 20.0. */ declare public readonly driftDeltaPercent: pulumi.Output; + /** + * Emergency response configuration for OOM and CPU throttle events. + */ + declare public readonly emergencyResponse: pulumi.Output; declare public readonly enableInPlaceVerticalScaling: pulumi.Output; /** * Raise requests to cover observed peak usage when the peak/recommendation ratio exceeds pmaxRatioThreshold. Default: false. @@ -168,6 +172,7 @@ export class WorkloadPolicy extends pulumi.CustomResource { resourceInputs["description"] = args?.description; resourceInputs["detectionTriggers"] = args?.detectionTriggers; resourceInputs["driftDeltaPercent"] = args?.driftDeltaPercent; + resourceInputs["emergencyResponse"] = args?.emergencyResponse; resourceInputs["enableInPlaceVerticalScaling"] = args?.enableInPlaceVerticalScaling; resourceInputs["enablePmaxProtection"] = args?.enablePmaxProtection; resourceInputs["gpuVerticalScaling"] = args ? (args.gpuVerticalScaling ? pulumi.output(args.gpuVerticalScaling).apply(inputs.resources.verticalScalingArgsArgsProvideDefaults) : undefined) : undefined; @@ -213,6 +218,7 @@ export class WorkloadPolicy extends pulumi.CustomResource { resourceInputs["description"] = undefined /*out*/; resourceInputs["detectionTriggers"] = undefined /*out*/; resourceInputs["driftDeltaPercent"] = undefined /*out*/; + resourceInputs["emergencyResponse"] = undefined /*out*/; resourceInputs["enableInPlaceVerticalScaling"] = undefined /*out*/; resourceInputs["enablePmaxProtection"] = undefined /*out*/; resourceInputs["gpuVerticalScaling"] = undefined /*out*/; @@ -288,6 +294,10 @@ export interface WorkloadPolicyArgs { * Percentage change from the baseline recommendation that triggers a VPA refresh. Example: 20.0. */ driftDeltaPercent?: pulumi.Input; + /** + * Emergency response configuration for OOM and CPU throttle events. + */ + emergencyResponse?: pulumi.Input; enableInPlaceVerticalScaling?: pulumi.Input; /** * Raise requests to cover observed peak usage when the peak/recommendation ratio exceeds pmaxRatioThreshold. Default: false. diff --git a/sdk/nodejs/resources/workloadRule.ts b/sdk/nodejs/resources/workloadRule.ts index 36f13a6..16f1bca 100644 --- a/sdk/nodejs/resources/workloadRule.ts +++ b/sdk/nodejs/resources/workloadRule.ts @@ -37,6 +37,10 @@ export class WorkloadRule extends pulumi.CustomResource { * When to apply recommendations. Valid values: 'on_detection', 'on_schedule'. Example: ["on_detection"]. */ declare public readonly actionTriggers: pulumi.Output; + /** + * Allow in-place vertical scaling to decrease the memory limit (normally only requests shrink; limits only grow). Example: false. + */ + declare public readonly allowInPlaceMemoryLimitDecrease: pulumi.Output; /** * When true the engine generates all rule fields automatically; manual field overrides are ignored. Example: false. */ @@ -82,6 +86,18 @@ export class WorkloadRule extends pulumi.CustomResource { * Horizontal (replica) scaling rule configuration. */ declare public readonly hpaRule: pulumi.Output; + /** + * Minimum CPU request in millicores during JVM startup, to avoid slow JIT warmup on undersized CPU. Example: 500. + */ + declare public readonly jvmCpuStartupFloorMillicores: pulumi.Output; + /** + * JVM heap sizing overrides applied to detected Java containers. + */ + declare public readonly jvmHeapRule: pulumi.Output; + /** + * KEDA ScaledObject configuration managed alongside this workload. + */ + declare public readonly kedaScaledObject: pulumi.Output; /** * Kubernetes workload kind. One of: 'Deployment', 'StatefulSet', 'DaemonSet', 'CronJob', 'Job'. Example: 'Deployment'. */ @@ -140,6 +156,7 @@ export class WorkloadRule extends pulumi.CustomResource { throw new Error("Missing required property 'namespace'"); } resourceInputs["actionTriggers"] = args?.actionTriggers; + resourceInputs["allowInPlaceMemoryLimitDecrease"] = args?.allowInPlaceMemoryLimitDecrease; resourceInputs["autoGenerate"] = args?.autoGenerate; resourceInputs["clusterId"] = args?.clusterId; resourceInputs["containers"] = args?.containers; @@ -152,6 +169,9 @@ export class WorkloadRule extends pulumi.CustomResource { resourceInputs["emergencyResponse"] = args?.emergencyResponse; resourceInputs["gpuRule"] = args?.gpuRule; resourceInputs["hpaRule"] = args?.hpaRule; + resourceInputs["jvmCpuStartupFloorMillicores"] = args?.jvmCpuStartupFloorMillicores; + resourceInputs["jvmHeapRule"] = args?.jvmHeapRule; + resourceInputs["kedaScaledObject"] = args?.kedaScaledObject; resourceInputs["kind"] = args?.kind; resourceInputs["liveMigrationEnabled"] = args?.liveMigrationEnabled; resourceInputs["lookbackPeriodSeconds"] = args?.lookbackPeriodSeconds; @@ -163,6 +183,7 @@ export class WorkloadRule extends pulumi.CustomResource { resourceInputs["useInPlaceVerticalScaling"] = args?.useInPlaceVerticalScaling; } else { resourceInputs["actionTriggers"] = undefined /*out*/; + resourceInputs["allowInPlaceMemoryLimitDecrease"] = undefined /*out*/; resourceInputs["autoGenerate"] = undefined /*out*/; resourceInputs["clusterId"] = undefined /*out*/; resourceInputs["containers"] = undefined /*out*/; @@ -175,6 +196,9 @@ export class WorkloadRule extends pulumi.CustomResource { resourceInputs["emergencyResponse"] = undefined /*out*/; resourceInputs["gpuRule"] = undefined /*out*/; resourceInputs["hpaRule"] = undefined /*out*/; + resourceInputs["jvmCpuStartupFloorMillicores"] = undefined /*out*/; + resourceInputs["jvmHeapRule"] = undefined /*out*/; + resourceInputs["kedaScaledObject"] = undefined /*out*/; resourceInputs["kind"] = undefined /*out*/; resourceInputs["liveMigrationEnabled"] = undefined /*out*/; resourceInputs["lookbackPeriodSeconds"] = undefined /*out*/; @@ -198,6 +222,10 @@ export interface WorkloadRuleArgs { * When to apply recommendations. Valid values: 'on_detection', 'on_schedule'. Example: ["on_detection"]. */ actionTriggers?: pulumi.Input[]>; + /** + * Allow in-place vertical scaling to decrease the memory limit (normally only requests shrink; limits only grow). Example: false. + */ + allowInPlaceMemoryLimitDecrease?: pulumi.Input; /** * When true the engine generates all rule fields automatically; manual field overrides are ignored. Example: false. */ @@ -243,6 +271,18 @@ export interface WorkloadRuleArgs { * Horizontal (replica) scaling rule configuration. */ hpaRule?: pulumi.Input; + /** + * Minimum CPU request in millicores during JVM startup, to avoid slow JIT warmup on undersized CPU. Example: 500. + */ + jvmCpuStartupFloorMillicores?: pulumi.Input; + /** + * JVM heap sizing overrides applied to detected Java containers. + */ + jvmHeapRule?: pulumi.Input; + /** + * KEDA ScaledObject configuration managed alongside this workload. + */ + kedaScaledObject?: pulumi.Input; /** * Kubernetes workload kind. One of: 'Deployment', 'StatefulSet', 'DaemonSet', 'CronJob', 'Job'. Example: 'Deployment'. */ diff --git a/sdk/nodejs/types/input.ts b/sdk/nodejs/types/input.ts index b539699..448f841 100644 --- a/sdk/nodejs/types/input.ts +++ b/sdk/nodejs/types/input.ts @@ -342,6 +342,75 @@ export namespace resources { oomMemoryMultiplier?: pulumi.Input; } + export interface GCPDiskArgsArgs { + /** + * Whether this disk is the boot disk. Example: true. + */ + boot?: pulumi.Input; + /** + * GCP disk type. Example: 'pd-ssd'. + */ + category?: pulumi.Input; + /** + * Secondary boot image used for container-image fast boot. Example: 'projects/my-project/global/images/my-cache-image'. + */ + secondaryBootImage?: pulumi.Input; + /** + * Secondary boot mode. Example: 'CONTAINER_IMAGE_CACHE'. + */ + secondaryBootMode?: pulumi.Input; + /** + * Disk size in GiB. Example: 100. + */ + sizeGib?: pulumi.Input; + } + + export interface GCPImageSelectorTermArgsArgs { + /** + * Well-known alias for the GCP node image family. Example: 'cos@latest'. + */ + alias?: pulumi.Input; + /** + * Explicit GCP image ID. Example: 'projects/cos-cloud/global/images/cos-105-17412-156-59'. + */ + id?: pulumi.Input; + } + + export interface GCPNodeClassSpecArgsArgs { + /** + * Disks attached to provisioned nodes. Example: [{sizeGib: 100, category: "pd-ssd", boot: true}]. + */ + disks?: pulumi.Input[]>; + /** + * GCP node image family shorthand used when no imageSelectorTerms are specified. Example: 'cos'. + */ + imageFamily?: pulumi.Input; + /** + * Selectors for the node images used to launch nodes. Example: [{alias: "cos@latest"}]. + */ + imageSelectorTerms?: pulumi.Input[]>; + /** + * Kubelet configuration overrides applied to all nodes in this class. + */ + kubelet?: pulumi.Input; + /** + * GCP labels applied to all resources created by this node class. Example: {"environment": "production"}. + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * GCE instance metadata applied to provisioned nodes. Example: {"disable-legacy-endpoints": "true"}. + */ + metadata?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * GCP network tags applied to provisioned nodes for firewall targeting. Example: ["karpenter-node"]. + */ + networkTags?: pulumi.Input[]>; + /** + * GCP service account email attached to provisioned nodes. Example: 'karpenter@my-project.iam.gserviceaccount.com'. + */ + serviceAccount?: pulumi.Input; + } + export interface HPABehaviorArgsArgs { /** * Scale-down behavior rules. @@ -504,6 +573,144 @@ export namespace resources { targetUtilization?: pulumi.Input; } + export interface JvmHeapRuleConfigArgsArgs { + /** + * Enable JVM heap sizing overrides. Example: true. + */ + enabled?: pulumi.Input; + /** + * Multiplier applied above the target usage to derive the heap size. Example: 1.3. + */ + headroomMultiplier?: pulumi.Input; + /** + * Maximum JVM heap size in bytes. Example: 2147483648. + */ + maxHeapBytes?: pulumi.Input; + /** + * Minimum JVM heap size in bytes. Example: 134217728. + */ + minHeapBytes?: pulumi.Input; + /** + * Non-heap memory overhead in bytes. Takes precedence over nonHeapOverheadPercent when set. Example: 268435456. + */ + nonHeapOverheadBytes?: pulumi.Input; + /** + * Non-heap memory overhead as a percentage of container memory (0-1). Example: 0.2. + */ + nonHeapOverheadPercent?: pulumi.Input; + /** + * Prefer the JVM's native container-aware heap sizing (-XX:+UseContainerSupport) over explicit -Xmx/-Xms flags. Example: false. + */ + preferContainerSupport?: pulumi.Input; + /** + * Percentile of usage data used as the heap sizing target (0-1). Example: 0.95. + */ + targetPercentile?: pulumi.Input; + } + + export interface KedaAdvancedArgsArgs { + /** + * Kubernetes HorizontalPodAutoscalerBehavior encoded as a JSON string, applied to the generated HPA. Example: '{"scaleDown":{"stabilizationWindowSeconds":300}}'. + */ + advancedBehaviorJson?: pulumi.Input; + /** + * Restore the original replica count when the ScaledObject is deleted. Example: false. + */ + restoreToOriginalReplicaCount?: pulumi.Input; + } + + export interface KedaAuthenticationRefArgsArgs { + /** + * Kind of the referenced resource. One of: 'TriggerAuthentication', 'ClusterTriggerAuthentication'. Example: 'TriggerAuthentication'. + */ + kind?: pulumi.Input; + /** + * Name of the referenced TriggerAuthentication/ClusterTriggerAuthentication resource. Example: 'prometheus-auth'. + */ + name: pulumi.Input; + } + + export interface KedaFallbackArgsArgs { + /** + * Fallback strategy. Example: 'static'. + */ + behavior?: pulumi.Input; + /** + * Number of consecutive metric failures before activating fallback. Example: 3. + */ + failureThreshold: pulumi.Input; + /** + * Number of replicas to fall back to when metrics are unavailable. Example: 2. + */ + replicas: pulumi.Input; + } + + export interface KedaScaledObjectArgsArgs { + /** + * Advanced ScaledObject behavior configuration. + */ + advanced?: pulumi.Input; + /** + * Seconds to wait after the last trigger reports active=false before scaling to minReplicaCount. Example: 300. + */ + cooldownPeriod?: pulumi.Input; + /** + * Replica fallback configuration when KEDA metrics are unavailable. + */ + fallback?: pulumi.Input; + /** + * Replica count to scale to when idle. Must be less than minReplicaCount. Example: 0. + */ + idleReplicaCount?: pulumi.Input; + /** + * Cooldown period applied only during the initial scaling of the ScaledObject. Example: 0. + */ + initialCooldownPeriod?: pulumi.Input; + /** + * Maximum number of replicas. Example: 10. + */ + maxReplicaCount?: pulumi.Input; + /** + * Minimum number of replicas. Example: 0. + */ + minReplicaCount?: pulumi.Input; + /** + * Seconds between checks of trigger metrics. Example: 30. + */ + pollingInterval?: pulumi.Input; + /** + * KEDA scaler triggers driving this ScaledObject. + */ + triggers?: pulumi.Input[]>; + } + + export interface KedaTriggerArgsArgs { + /** + * Reference to a TriggerAuthentication or ClusterTriggerAuthentication for this trigger. + */ + authenticationRef?: pulumi.Input; + /** + * Scaler-specific configuration key-value pairs. Example: {"serverAddress": "http://prometheus:9090", "query": "sum(rate(http_requests_total[2m]))"}. + */ + metadata?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * Metric target type. One of: 'Value', 'AverageValue', 'Utilization'. Example: 'AverageValue'. + */ + metricType?: pulumi.Input; + /** + * Optional trigger name, used to disambiguate multiple triggers of the same type. Example: 'requests-per-second'. + */ + name?: pulumi.Input; + /** + * KEDA scaler type. Example: 'prometheus'. + */ + type: pulumi.Input; + /** + * Use KEDA's metric caching for this trigger. Example: false. + */ + useCachedMetrics?: pulumi.Input; + } + export interface KubeletConfigurationArgsArgs { /** * DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. @@ -611,6 +818,147 @@ export namespace resources { pattern?: pulumi.Input; } + export interface OCIBootConfigArgsArgs { + /** + * Boot volume size in GB. Example: 100. + */ + bootVolumeSizeInGbs?: pulumi.Input; + /** + * Boot volume performance units per GB. Example: 10. + */ + bootVolumeVpusPerGb?: pulumi.Input; + } + + export interface OCIImageSelectorTermArgsArgs { + /** + * OCID of the compartment containing the image. Example: 'ocid1.compartment.oc1..aaaaaaaa'. + */ + compartmentId?: pulumi.Input; + /** + * Explicit OCI image OCID. Example: 'ocid1.image.oc1..aaaaaaaa'. + */ + id?: pulumi.Input; + /** + * OCI image display name filter. Example: 'Oracle-Linux-8.9'. + */ + name?: pulumi.Input; + } + + export interface OCILaunchOptionsArgsArgs { + /** + * Emulation type for the boot volume. Example: 'PARAVIRTUALIZED'. + */ + bootVolumeType?: pulumi.Input; + /** + * Firmware used to boot the instance. Example: 'UEFI_64'. + */ + firmware?: pulumi.Input; + /** + * Whether consistent volume naming is enabled for the instance. Example: true. + */ + isConsistentVolumeNamingEnabled?: pulumi.Input; + /** + * Emulation type for the network interface. Example: 'PARAVIRTUALIZED'. + */ + networkType?: pulumi.Input; + /** + * Emulation type for remote data volumes. Example: 'PARAVIRTUALIZED'. + */ + remoteDataVolumeType?: pulumi.Input; + } + + export interface OCINodeClassSpecArgsArgs { + /** + * OCI compute instance agent plugins to enable. Example: ["Compute Instance Monitoring"]. + */ + agentList?: pulumi.Input[]>; + /** + * Additional block volumes attached to provisioned nodes. + */ + blockDevices?: pulumi.Input[]>; + /** + * Boot volume configuration for provisioned nodes. + */ + bootConfig?: pulumi.Input; + /** + * OCI free-form tags applied to all resources created by this node class. Example: {"environment": "production"}. + */ + freeFormTags?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * OCI node image family shorthand used when no imageSelector is specified. Example: 'Oracle-Linux-8'. + */ + imageFamily?: pulumi.Input; + /** + * Selectors for the images used to launch nodes. Example: [{name: "Oracle-Linux-8.9"}]. + */ + imageSelector?: pulumi.Input[]>; + /** + * Instance launch options controlling firmware and network/volume emulation type. + */ + launchOptions?: pulumi.Input; + /** + * OCI instance metadata applied to provisioned nodes. Example: {"ssh_authorized_keys": "ssh-rsa ..."}. + */ + metaData?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * Script executed before node bootstrap. Example: '#!/bin/bash\necho pre-install'. + */ + preInstallScript?: pulumi.Input; + /** + * Selectors for network security groups attached to provisioned nodes. + */ + securityGroupSelector?: pulumi.Input[]>; + /** + * Selectors for the subnets nodes will be launched into. + */ + subnetSelector?: pulumi.Input[]>; + /** + * OCI defined tags applied to all resources created by this node class. + */ + tags?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * Custom cloud-init user data merged into the node launch config (base64 or plain text). Example: '#!/bin/bash\necho hello'. + */ + userData?: pulumi.Input; + /** + * OCID of the VCN nodes will be launched into. Example: 'ocid1.vcn.oc1..aaaaaaaa'. + */ + vcnId?: pulumi.Input; + } + + export interface OCISecurityGroupSelectorTermArgsArgs { + /** + * Explicit OCI network security group OCID. Example: 'ocid1.networksecuritygroup.oc1..aaaaaaaa'. + */ + id?: pulumi.Input; + /** + * OCI network security group display name filter. Example: 'node-nsg'. + */ + name?: pulumi.Input; + } + + export interface OCISubnetSelectorTermArgsArgs { + /** + * Explicit OCI subnet OCID. Example: 'ocid1.subnet.oc1..aaaaaaaa'. + */ + id?: pulumi.Input; + /** + * OCI subnet display name filter. Example: 'node-subnet'. + */ + name?: pulumi.Input; + } + + export interface OCIVolumeAttributesArgsArgs { + /** + * Block volume size in GB. Example: 50. + */ + sizeInGbs?: pulumi.Input; + /** + * Block volume performance units per GB. Example: 10. + */ + vpusPerGb?: pulumi.Input; + } + export interface RawKarpenterSpecArgsArgs { /** * Raw YAML for a complete Karpenter NodeClass resource — use as an escape hatch when structured fields are insufficient. Example: 'apiVersion: karpenter.k8s.aws/v1\nkind: EC2NodeClass\nmetadata:\n name: default\n...'. diff --git a/sdk/nodejs/types/output.ts b/sdk/nodejs/types/output.ts index b9cf08b..8c627e2 100644 --- a/sdk/nodejs/types/output.ts +++ b/sdk/nodejs/types/output.ts @@ -342,6 +342,75 @@ export namespace resources { oomMemoryMultiplier?: number; } + export interface GCPDiskArgs { + /** + * Whether this disk is the boot disk. Example: true. + */ + boot?: boolean; + /** + * GCP disk type. Example: 'pd-ssd'. + */ + category?: string; + /** + * Secondary boot image used for container-image fast boot. Example: 'projects/my-project/global/images/my-cache-image'. + */ + secondaryBootImage?: string; + /** + * Secondary boot mode. Example: 'CONTAINER_IMAGE_CACHE'. + */ + secondaryBootMode?: string; + /** + * Disk size in GiB. Example: 100. + */ + sizeGib?: number; + } + + export interface GCPImageSelectorTermArgs { + /** + * Well-known alias for the GCP node image family. Example: 'cos@latest'. + */ + alias?: string; + /** + * Explicit GCP image ID. Example: 'projects/cos-cloud/global/images/cos-105-17412-156-59'. + */ + id?: string; + } + + export interface GCPNodeClassSpecArgs { + /** + * Disks attached to provisioned nodes. Example: [{sizeGib: 100, category: "pd-ssd", boot: true}]. + */ + disks?: outputs.resources.GCPDiskArgs[]; + /** + * GCP node image family shorthand used when no imageSelectorTerms are specified. Example: 'cos'. + */ + imageFamily?: string; + /** + * Selectors for the node images used to launch nodes. Example: [{alias: "cos@latest"}]. + */ + imageSelectorTerms?: outputs.resources.GCPImageSelectorTermArgs[]; + /** + * Kubelet configuration overrides applied to all nodes in this class. + */ + kubelet?: outputs.resources.KubeletConfigurationArgs; + /** + * GCP labels applied to all resources created by this node class. Example: {"environment": "production"}. + */ + labels?: {[key: string]: string}; + /** + * GCE instance metadata applied to provisioned nodes. Example: {"disable-legacy-endpoints": "true"}. + */ + metadata?: {[key: string]: string}; + /** + * GCP network tags applied to provisioned nodes for firewall targeting. Example: ["karpenter-node"]. + */ + networkTags?: string[]; + /** + * GCP service account email attached to provisioned nodes. Example: 'karpenter@my-project.iam.gserviceaccount.com'. + */ + serviceAccount?: string; + } + export interface HPABehaviorArgs { /** * Scale-down behavior rules. @@ -504,6 +573,144 @@ export namespace resources { targetUtilization?: number; } + export interface JvmHeapRuleConfigArgs { + /** + * Enable JVM heap sizing overrides. Example: true. + */ + enabled?: boolean; + /** + * Multiplier applied above the target usage to derive the heap size. Example: 1.3. + */ + headroomMultiplier?: number; + /** + * Maximum JVM heap size in bytes. Example: 2147483648. + */ + maxHeapBytes?: number; + /** + * Minimum JVM heap size in bytes. Example: 134217728. + */ + minHeapBytes?: number; + /** + * Non-heap memory overhead in bytes. Takes precedence over nonHeapOverheadPercent when set. Example: 268435456. + */ + nonHeapOverheadBytes?: number; + /** + * Non-heap memory overhead as a percentage of container memory (0-1). Example: 0.2. + */ + nonHeapOverheadPercent?: number; + /** + * Prefer the JVM's native container-aware heap sizing (-XX:+UseContainerSupport) over explicit -Xmx/-Xms flags. Example: false. + */ + preferContainerSupport?: boolean; + /** + * Percentile of usage data used as the heap sizing target (0-1). Example: 0.95. + */ + targetPercentile?: number; + } + + export interface KedaAdvancedArgs { + /** + * Kubernetes HorizontalPodAutoscalerBehavior encoded as a JSON string, applied to the generated HPA. Example: '{"scaleDown":{"stabilizationWindowSeconds":300}}'. + */ + advancedBehaviorJson?: string; + /** + * Restore the original replica count when the ScaledObject is deleted. Example: false. + */ + restoreToOriginalReplicaCount?: boolean; + } + + export interface KedaAuthenticationRefArgs { + /** + * Kind of the referenced resource. One of: 'TriggerAuthentication', 'ClusterTriggerAuthentication'. Example: 'TriggerAuthentication'. + */ + kind?: string; + /** + * Name of the referenced TriggerAuthentication/ClusterTriggerAuthentication resource. Example: 'prometheus-auth'. + */ + name: string; + } + + export interface KedaFallbackArgs { + /** + * Fallback strategy. Example: 'static'. + */ + behavior?: string; + /** + * Number of consecutive metric failures before activating fallback. Example: 3. + */ + failureThreshold: number; + /** + * Number of replicas to fall back to when metrics are unavailable. Example: 2. + */ + replicas: number; + } + + export interface KedaScaledObjectArgs { + /** + * Advanced ScaledObject behavior configuration. + */ + advanced?: outputs.resources.KedaAdvancedArgs; + /** + * Seconds to wait after the last trigger reports active=false before scaling to minReplicaCount. Example: 300. + */ + cooldownPeriod?: number; + /** + * Replica fallback configuration when KEDA metrics are unavailable. + */ + fallback?: outputs.resources.KedaFallbackArgs; + /** + * Replica count to scale to when idle. Must be less than minReplicaCount. Example: 0. + */ + idleReplicaCount?: number; + /** + * Cooldown period applied only during the initial scaling of the ScaledObject. Example: 0. + */ + initialCooldownPeriod?: number; + /** + * Maximum number of replicas. Example: 10. + */ + maxReplicaCount?: number; + /** + * Minimum number of replicas. Example: 0. + */ + minReplicaCount?: number; + /** + * Seconds between checks of trigger metrics. Example: 30. + */ + pollingInterval?: number; + /** + * KEDA scaler triggers driving this ScaledObject. + */ + triggers?: outputs.resources.KedaTriggerArgs[]; + } + + export interface KedaTriggerArgs { + /** + * Reference to a TriggerAuthentication or ClusterTriggerAuthentication for this trigger. + */ + authenticationRef?: outputs.resources.KedaAuthenticationRefArgs; + /** + * Scaler-specific configuration key-value pairs. Example: {"serverAddress": "http://prometheus:9090", "query": "sum(rate(http_requests_total[2m]))"}. + */ + metadata?: {[key: string]: string}; + /** + * Metric target type. One of: 'Value', 'AverageValue', 'Utilization'. Example: 'AverageValue'. + */ + metricType?: string; + /** + * Optional trigger name, used to disambiguate multiple triggers of the same type. Example: 'requests-per-second'. + */ + name?: string; + /** + * KEDA scaler type. Example: 'prometheus'. + */ + type: string; + /** + * Use KEDA's metric caching for this trigger. Example: false. + */ + useCachedMetrics?: boolean; + } + export interface KubeletConfigurationArgs { /** * DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. @@ -611,6 +818,147 @@ export namespace resources { pattern?: string; } + export interface OCIBootConfigArgs { + /** + * Boot volume size in GB. Example: 100. + */ + bootVolumeSizeInGbs?: number; + /** + * Boot volume performance units per GB. Example: 10. + */ + bootVolumeVpusPerGb?: number; + } + + export interface OCIImageSelectorTermArgs { + /** + * OCID of the compartment containing the image. Example: 'ocid1.compartment.oc1..aaaaaaaa'. + */ + compartmentId?: string; + /** + * Explicit OCI image OCID. Example: 'ocid1.image.oc1..aaaaaaaa'. + */ + id?: string; + /** + * OCI image display name filter. Example: 'Oracle-Linux-8.9'. + */ + name?: string; + } + + export interface OCILaunchOptionsArgs { + /** + * Emulation type for the boot volume. Example: 'PARAVIRTUALIZED'. + */ + bootVolumeType?: string; + /** + * Firmware used to boot the instance. Example: 'UEFI_64'. + */ + firmware?: string; + /** + * Whether consistent volume naming is enabled for the instance. Example: true. + */ + isConsistentVolumeNamingEnabled?: boolean; + /** + * Emulation type for the network interface. Example: 'PARAVIRTUALIZED'. + */ + networkType?: string; + /** + * Emulation type for remote data volumes. Example: 'PARAVIRTUALIZED'. + */ + remoteDataVolumeType?: string; + } + + export interface OCINodeClassSpecArgs { + /** + * OCI compute instance agent plugins to enable. Example: ["Compute Instance Monitoring"]. + */ + agentList?: string[]; + /** + * Additional block volumes attached to provisioned nodes. + */ + blockDevices?: outputs.resources.OCIVolumeAttributesArgs[]; + /** + * Boot volume configuration for provisioned nodes. + */ + bootConfig?: outputs.resources.OCIBootConfigArgs; + /** + * OCI free-form tags applied to all resources created by this node class. Example: {"environment": "production"}. + */ + freeFormTags?: {[key: string]: string}; + /** + * OCI node image family shorthand used when no imageSelector is specified. Example: 'Oracle-Linux-8'. + */ + imageFamily?: string; + /** + * Selectors for the images used to launch nodes. Example: [{name: "Oracle-Linux-8.9"}]. + */ + imageSelector?: outputs.resources.OCIImageSelectorTermArgs[]; + /** + * Instance launch options controlling firmware and network/volume emulation type. + */ + launchOptions?: outputs.resources.OCILaunchOptionsArgs; + /** + * OCI instance metadata applied to provisioned nodes. Example: {"ssh_authorized_keys": "ssh-rsa ..."}. + */ + metaData?: {[key: string]: string}; + /** + * Script executed before node bootstrap. Example: '#!/bin/bash\necho pre-install'. + */ + preInstallScript?: string; + /** + * Selectors for network security groups attached to provisioned nodes. + */ + securityGroupSelector?: outputs.resources.OCISecurityGroupSelectorTermArgs[]; + /** + * Selectors for the subnets nodes will be launched into. + */ + subnetSelector?: outputs.resources.OCISubnetSelectorTermArgs[]; + /** + * OCI defined tags applied to all resources created by this node class. + */ + tags?: {[key: string]: string}; + /** + * Custom cloud-init user data merged into the node launch config (base64 or plain text). Example: '#!/bin/bash\necho hello'. + */ + userData?: string; + /** + * OCID of the VCN nodes will be launched into. Example: 'ocid1.vcn.oc1..aaaaaaaa'. + */ + vcnId?: string; + } + + export interface OCISecurityGroupSelectorTermArgs { + /** + * Explicit OCI network security group OCID. Example: 'ocid1.networksecuritygroup.oc1..aaaaaaaa'. + */ + id?: string; + /** + * OCI network security group display name filter. Example: 'node-nsg'. + */ + name?: string; + } + + export interface OCISubnetSelectorTermArgs { + /** + * Explicit OCI subnet OCID. Example: 'ocid1.subnet.oc1..aaaaaaaa'. + */ + id?: string; + /** + * OCI subnet display name filter. Example: 'node-subnet'. + */ + name?: string; + } + + export interface OCIVolumeAttributesArgs { + /** + * Block volume size in GB. Example: 50. + */ + sizeInGbs?: number; + /** + * Block volume performance units per GB. Example: 10. + */ + vpusPerGb?: number; + } + export interface RawKarpenterSpecArgs { /** * Raw YAML for a complete Karpenter NodeClass resource — use as an escape hatch when structured fields are insufficient. Example: 'apiVersion: karpenter.k8s.aws/v1\nkind: EC2NodeClass\nmetadata:\n name: default\n...'. diff --git a/sdk/python/pulumi_devzero/resources/_inputs.py b/sdk/python/pulumi_devzero/resources/_inputs.py index 4dc3c12..a8c249d 100644 --- a/sdk/python/pulumi_devzero/resources/_inputs.py +++ b/sdk/python/pulumi_devzero/resources/_inputs.py @@ -37,6 +37,12 @@ 'DisruptionPolicyArgsArgsDict', 'EmergencyResponseConfigArgsArgs', 'EmergencyResponseConfigArgsArgsDict', + 'GCPDiskArgsArgs', + 'GCPDiskArgsArgsDict', + 'GCPImageSelectorTermArgsArgs', + 'GCPImageSelectorTermArgsArgsDict', + 'GCPNodeClassSpecArgsArgs', + 'GCPNodeClassSpecArgsArgsDict', 'HPABehaviorArgsArgs', 'HPABehaviorArgsArgsDict', 'HPAFallbackArgsArgs', @@ -51,6 +57,18 @@ 'HPAScalingRulesArgsArgsDict', 'HorizontalScalingArgsArgs', 'HorizontalScalingArgsArgsDict', + 'JvmHeapRuleConfigArgsArgs', + 'JvmHeapRuleConfigArgsArgsDict', + 'KedaAdvancedArgsArgs', + 'KedaAdvancedArgsArgsDict', + 'KedaAuthenticationRefArgsArgs', + 'KedaAuthenticationRefArgsArgsDict', + 'KedaFallbackArgsArgs', + 'KedaFallbackArgsArgsDict', + 'KedaScaledObjectArgsArgs', + 'KedaScaledObjectArgsArgsDict', + 'KedaTriggerArgsArgs', + 'KedaTriggerArgsArgsDict', 'KubeletConfigurationArgsArgs', 'KubeletConfigurationArgsArgsDict', 'LabelSelectorArgsArgs', @@ -61,6 +79,20 @@ 'MetadataOptionsArgsArgsDict', 'NamePatternArgsArgs', 'NamePatternArgsArgsDict', + 'OCIBootConfigArgsArgs', + 'OCIBootConfigArgsArgsDict', + 'OCIImageSelectorTermArgsArgs', + 'OCIImageSelectorTermArgsArgsDict', + 'OCILaunchOptionsArgsArgs', + 'OCILaunchOptionsArgsArgsDict', + 'OCINodeClassSpecArgsArgs', + 'OCINodeClassSpecArgsArgsDict', + 'OCISecurityGroupSelectorTermArgsArgs', + 'OCISecurityGroupSelectorTermArgsArgsDict', + 'OCISubnetSelectorTermArgsArgs', + 'OCISubnetSelectorTermArgsArgsDict', + 'OCIVolumeAttributesArgsArgs', + 'OCIVolumeAttributesArgsArgsDict', 'RawKarpenterSpecArgsArgs', 'RawKarpenterSpecArgsArgsDict', 'ResourceLimitsArgsArgs', @@ -1690,6 +1722,333 @@ def oom_memory_multiplier(self, value: Optional[pulumi.Input[_builtins.float]]): pulumi.set(self, "oom_memory_multiplier", value) +class GCPDiskArgsArgsDict(TypedDict): + boot: NotRequired[pulumi.Input[_builtins.bool]] + """ + Whether this disk is the boot disk. Example: true. + """ + category: NotRequired[pulumi.Input[_builtins.str]] + """ + GCP disk type. Example: 'pd-ssd'. + """ + secondary_boot_image: NotRequired[pulumi.Input[_builtins.str]] + """ + Secondary boot image used for container-image fast boot. Example: 'projects/my-project/global/images/my-cache-image'. + """ + secondary_boot_mode: NotRequired[pulumi.Input[_builtins.str]] + """ + Secondary boot mode. Example: 'CONTAINER_IMAGE_CACHE'. + """ + size_gib: NotRequired[pulumi.Input[_builtins.int]] + """ + Disk size in GiB. Example: 100. + """ + +@pulumi.input_type +class GCPDiskArgsArgs: + def __init__(__self__, *, + boot: Optional[pulumi.Input[_builtins.bool]] = None, + category: Optional[pulumi.Input[_builtins.str]] = None, + secondary_boot_image: Optional[pulumi.Input[_builtins.str]] = None, + secondary_boot_mode: Optional[pulumi.Input[_builtins.str]] = None, + size_gib: Optional[pulumi.Input[_builtins.int]] = None): + """ + :param pulumi.Input[_builtins.bool] boot: Whether this disk is the boot disk. Example: true. + :param pulumi.Input[_builtins.str] category: GCP disk type. Example: 'pd-ssd'. + :param pulumi.Input[_builtins.str] secondary_boot_image: Secondary boot image used for container-image fast boot. Example: 'projects/my-project/global/images/my-cache-image'. + :param pulumi.Input[_builtins.str] secondary_boot_mode: Secondary boot mode. Example: 'CONTAINER_IMAGE_CACHE'. + :param pulumi.Input[_builtins.int] size_gib: Disk size in GiB. Example: 100. + """ + if boot is not None: + pulumi.set(__self__, "boot", boot) + if category is not None: + pulumi.set(__self__, "category", category) + if secondary_boot_image is not None: + pulumi.set(__self__, "secondary_boot_image", secondary_boot_image) + if secondary_boot_mode is not None: + pulumi.set(__self__, "secondary_boot_mode", secondary_boot_mode) + if size_gib is not None: + pulumi.set(__self__, "size_gib", size_gib) + + @_builtins.property + @pulumi.getter + def boot(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Whether this disk is the boot disk. Example: true. + """ + return pulumi.get(self, "boot") + + @boot.setter + def boot(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "boot", value) + + @_builtins.property + @pulumi.getter + def category(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + GCP disk type. Example: 'pd-ssd'. + """ + return pulumi.get(self, "category") + + @category.setter + def category(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "category", value) + + @_builtins.property + @pulumi.getter(name="secondaryBootImage") + def secondary_boot_image(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Secondary boot image used for container-image fast boot. Example: 'projects/my-project/global/images/my-cache-image'. + """ + return pulumi.get(self, "secondary_boot_image") + + @secondary_boot_image.setter + def secondary_boot_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "secondary_boot_image", value) + + @_builtins.property + @pulumi.getter(name="secondaryBootMode") + def secondary_boot_mode(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Secondary boot mode. Example: 'CONTAINER_IMAGE_CACHE'. + """ + return pulumi.get(self, "secondary_boot_mode") + + @secondary_boot_mode.setter + def secondary_boot_mode(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "secondary_boot_mode", value) + + @_builtins.property + @pulumi.getter(name="sizeGib") + def size_gib(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Disk size in GiB. Example: 100. + """ + return pulumi.get(self, "size_gib") + + @size_gib.setter + def size_gib(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "size_gib", value) + + +class GCPImageSelectorTermArgsArgsDict(TypedDict): + alias: NotRequired[pulumi.Input[_builtins.str]] + """ + Well-known alias for the GCP node image family. Example: 'cos@latest'. + """ + id: NotRequired[pulumi.Input[_builtins.str]] + """ + Explicit GCP image ID. Example: 'projects/cos-cloud/global/images/cos-105-17412-156-59'. + """ + +@pulumi.input_type +class GCPImageSelectorTermArgsArgs: + def __init__(__self__, *, + alias: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] alias: Well-known alias for the GCP node image family. Example: 'cos@latest'. + :param pulumi.Input[_builtins.str] id: Explicit GCP image ID. Example: 'projects/cos-cloud/global/images/cos-105-17412-156-59'. + """ + if alias is not None: + pulumi.set(__self__, "alias", alias) + if id is not None: + pulumi.set(__self__, "id", id) + + @_builtins.property + @pulumi.getter + def alias(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Well-known alias for the GCP node image family. Example: 'cos@latest'. + """ + return pulumi.get(self, "alias") + + @alias.setter + def alias(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "alias", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Explicit GCP image ID. Example: 'projects/cos-cloud/global/images/cos-105-17412-156-59'. + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + +class GCPNodeClassSpecArgsArgsDict(TypedDict): + disks: NotRequired[pulumi.Input[Sequence[pulumi.Input['GCPDiskArgsArgsDict']]]] + """ + Disks attached to provisioned nodes. Example: [{sizeGib: 100, category: "pd-ssd", boot: true}]. + """ + image_family: NotRequired[pulumi.Input[_builtins.str]] + """ + GCP node image family shorthand used when no imageSelectorTerms are specified. Example: 'cos'. + """ + image_selector_terms: NotRequired[pulumi.Input[Sequence[pulumi.Input['GCPImageSelectorTermArgsArgsDict']]]] + """ + Selectors for the node images used to launch nodes. Example: [{alias: "cos@latest"}]. + """ + kubelet: NotRequired[pulumi.Input['KubeletConfigurationArgsArgsDict']] + """ + Kubelet configuration overrides applied to all nodes in this class. + """ + labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + """ + GCP labels applied to all resources created by this node class. Example: {"environment": "production"}. + """ + metadata: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + """ + GCE instance metadata applied to provisioned nodes. Example: {"disable-legacy-endpoints": "true"}. + """ + network_tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + GCP network tags applied to provisioned nodes for firewall targeting. Example: ["karpenter-node"]. + """ + service_account: NotRequired[pulumi.Input[_builtins.str]] + """ + GCP service account email attached to provisioned nodes. Example: 'karpenter@my-project.iam.gserviceaccount.com'. + """ + +@pulumi.input_type +class GCPNodeClassSpecArgsArgs: + def __init__(__self__, *, + disks: Optional[pulumi.Input[Sequence[pulumi.Input['GCPDiskArgsArgs']]]] = None, + image_family: Optional[pulumi.Input[_builtins.str]] = None, + image_selector_terms: Optional[pulumi.Input[Sequence[pulumi.Input['GCPImageSelectorTermArgsArgs']]]] = None, + kubelet: Optional[pulumi.Input['KubeletConfigurationArgsArgs']] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + network_tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + service_account: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['GCPDiskArgsArgs']]] disks: Disks attached to provisioned nodes. Example: [{sizeGib: 100, category: "pd-ssd", boot: true}]. + :param pulumi.Input[_builtins.str] image_family: GCP node image family shorthand used when no imageSelectorTerms are specified. Example: 'cos'. + :param pulumi.Input[Sequence[pulumi.Input['GCPImageSelectorTermArgsArgs']]] image_selector_terms: Selectors for the node images used to launch nodes. Example: [{alias: "cos@latest"}]. + :param pulumi.Input['KubeletConfigurationArgsArgs'] kubelet: Kubelet configuration overrides applied to all nodes in this class. + :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: GCP labels applied to all resources created by this node class. Example: {"environment": "production"}. + :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] metadata: GCE instance metadata applied to provisioned nodes. Example: {"disable-legacy-endpoints": "true"}. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] network_tags: GCP network tags applied to provisioned nodes for firewall targeting. Example: ["karpenter-node"]. + :param pulumi.Input[_builtins.str] service_account: GCP service account email attached to provisioned nodes. Example: 'karpenter@my-project.iam.gserviceaccount.com'. + """ + if disks is not None: + pulumi.set(__self__, "disks", disks) + if image_family is not None: + pulumi.set(__self__, "image_family", image_family) + if image_selector_terms is not None: + pulumi.set(__self__, "image_selector_terms", image_selector_terms) + if kubelet is not None: + pulumi.set(__self__, "kubelet", kubelet) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if metadata is not None: + pulumi.set(__self__, "metadata", metadata) + if network_tags is not None: + pulumi.set(__self__, "network_tags", network_tags) + if service_account is not None: + pulumi.set(__self__, "service_account", service_account) + + @_builtins.property + @pulumi.getter + def disks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['GCPDiskArgsArgs']]]]: + """ + Disks attached to provisioned nodes. Example: [{sizeGib: 100, category: "pd-ssd", boot: true}]. + """ + return pulumi.get(self, "disks") + + @disks.setter + def disks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['GCPDiskArgsArgs']]]]): + pulumi.set(self, "disks", value) + + @_builtins.property + @pulumi.getter(name="imageFamily") + def image_family(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + GCP node image family shorthand used when no imageSelectorTerms are specified. Example: 'cos'. + """ + return pulumi.get(self, "image_family") + + @image_family.setter + def image_family(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "image_family", value) + + @_builtins.property + @pulumi.getter(name="imageSelectorTerms") + def image_selector_terms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['GCPImageSelectorTermArgsArgs']]]]: + """ + Selectors for the node images used to launch nodes. Example: [{alias: "cos@latest"}]. + """ + return pulumi.get(self, "image_selector_terms") + + @image_selector_terms.setter + def image_selector_terms(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['GCPImageSelectorTermArgsArgs']]]]): + pulumi.set(self, "image_selector_terms", value) + + @_builtins.property + @pulumi.getter + def kubelet(self) -> Optional[pulumi.Input['KubeletConfigurationArgsArgs']]: + """ + Kubelet configuration overrides applied to all nodes in this class. + """ + return pulumi.get(self, "kubelet") + + @kubelet.setter + def kubelet(self, value: Optional[pulumi.Input['KubeletConfigurationArgsArgs']]): + pulumi.set(self, "kubelet", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + """ + GCP labels applied to all resources created by this node class. Example: {"environment": "production"}. + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter + def metadata(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + """ + GCE instance metadata applied to provisioned nodes. Example: {"disable-legacy-endpoints": "true"}. + """ + return pulumi.get(self, "metadata") + + @metadata.setter + def metadata(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "metadata", value) + + @_builtins.property + @pulumi.getter(name="networkTags") + def network_tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + GCP network tags applied to provisioned nodes for firewall targeting. Example: ["karpenter-node"]. + """ + return pulumi.get(self, "network_tags") + + @network_tags.setter + def network_tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "network_tags", value) + + @_builtins.property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + GCP service account email attached to provisioned nodes. Example: 'karpenter@my-project.iam.gserviceaccount.com'. + """ + return pulumi.get(self, "service_account") + + @service_account.setter + def service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_account", value) + + class HPABehaviorArgsArgsDict(TypedDict): scale_down: NotRequired[pulumi.Input['HPAScalingRulesArgsArgsDict']] """ @@ -2493,407 +2852,1057 @@ def target_utilization(self, value: Optional[pulumi.Input[_builtins.float]]): pulumi.set(self, "target_utilization", value) -class KubeletConfigurationArgsArgsDict(TypedDict): - cluster_dns: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] - """ - DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. - """ - cpu_cfs_quota: NotRequired[pulumi.Input[_builtins.bool]] - """ - Whether to enforce CPU CFS quota limits for containers. Example: true. - """ - eviction_hard: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] - """ - Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. - """ - eviction_max_pod_grace_period: NotRequired[pulumi.Input[_builtins.int]] - """ - Maximum pod termination grace period (seconds) during eviction. Example: 90. - """ - eviction_soft: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] +class JvmHeapRuleConfigArgsArgsDict(TypedDict): + enabled: NotRequired[pulumi.Input[_builtins.bool]] """ - Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. + Enable JVM heap sizing overrides. Example: true. """ - eviction_soft_grace_period: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + headroom_multiplier: NotRequired[pulumi.Input[_builtins.float]] """ - Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. + Multiplier applied above the target usage to derive the heap size. Example: 1.3. """ - image_gc_high_threshold_percent: NotRequired[pulumi.Input[_builtins.int]] + max_heap_bytes: NotRequired[pulumi.Input[_builtins.int]] """ - Disk usage % that triggers image garbage collection. Example: 85. + Maximum JVM heap size in bytes. Example: 2147483648. """ - image_gc_low_threshold_percent: NotRequired[pulumi.Input[_builtins.int]] + min_heap_bytes: NotRequired[pulumi.Input[_builtins.int]] """ - Disk usage % at which image GC stops freeing space. Example: 70. + Minimum JVM heap size in bytes. Example: 134217728. """ - kube_reserved: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + non_heap_overhead_bytes: NotRequired[pulumi.Input[_builtins.int]] """ - Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. + Non-heap memory overhead in bytes. Takes precedence over nonHeapOverheadPercent when set. Example: 268435456. """ - max_pods: NotRequired[pulumi.Input[_builtins.int]] + non_heap_overhead_percent: NotRequired[pulumi.Input[_builtins.float]] """ - Maximum number of pods allowed per node. Example: 110. + Non-heap memory overhead as a percentage of container memory (0-1). Example: 0.2. """ - pods_per_core: NotRequired[pulumi.Input[_builtins.int]] + prefer_container_support: NotRequired[pulumi.Input[_builtins.bool]] """ - Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. + Prefer the JVM's native container-aware heap sizing (-XX:+UseContainerSupport) over explicit -Xmx/-Xms flags. Example: false. """ - system_reserved: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + target_percentile: NotRequired[pulumi.Input[_builtins.float]] """ - Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. + Percentile of usage data used as the heap sizing target (0-1). Example: 0.95. """ @pulumi.input_type -class KubeletConfigurationArgsArgs: +class JvmHeapRuleConfigArgsArgs: def __init__(__self__, *, - cluster_dns: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, - cpu_cfs_quota: Optional[pulumi.Input[_builtins.bool]] = None, - eviction_hard: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, - eviction_max_pod_grace_period: Optional[pulumi.Input[_builtins.int]] = None, - eviction_soft: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, - eviction_soft_grace_period: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, - image_gc_high_threshold_percent: Optional[pulumi.Input[_builtins.int]] = None, - image_gc_low_threshold_percent: Optional[pulumi.Input[_builtins.int]] = None, - kube_reserved: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, - max_pods: Optional[pulumi.Input[_builtins.int]] = None, - pods_per_core: Optional[pulumi.Input[_builtins.int]] = None, - system_reserved: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None): + enabled: Optional[pulumi.Input[_builtins.bool]] = None, + headroom_multiplier: Optional[pulumi.Input[_builtins.float]] = None, + max_heap_bytes: Optional[pulumi.Input[_builtins.int]] = None, + min_heap_bytes: Optional[pulumi.Input[_builtins.int]] = None, + non_heap_overhead_bytes: Optional[pulumi.Input[_builtins.int]] = None, + non_heap_overhead_percent: Optional[pulumi.Input[_builtins.float]] = None, + prefer_container_support: Optional[pulumi.Input[_builtins.bool]] = None, + target_percentile: Optional[pulumi.Input[_builtins.float]] = None): """ - :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] cluster_dns: DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. - :param pulumi.Input[_builtins.bool] cpu_cfs_quota: Whether to enforce CPU CFS quota limits for containers. Example: true. - :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] eviction_hard: Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. - :param pulumi.Input[_builtins.int] eviction_max_pod_grace_period: Maximum pod termination grace period (seconds) during eviction. Example: 90. - :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] eviction_soft: Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. - :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] eviction_soft_grace_period: Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. - :param pulumi.Input[_builtins.int] image_gc_high_threshold_percent: Disk usage % that triggers image garbage collection. Example: 85. - :param pulumi.Input[_builtins.int] image_gc_low_threshold_percent: Disk usage % at which image GC stops freeing space. Example: 70. - :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] kube_reserved: Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. - :param pulumi.Input[_builtins.int] max_pods: Maximum number of pods allowed per node. Example: 110. - :param pulumi.Input[_builtins.int] pods_per_core: Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. - :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] system_reserved: Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. + :param pulumi.Input[_builtins.bool] enabled: Enable JVM heap sizing overrides. Example: true. + :param pulumi.Input[_builtins.float] headroom_multiplier: Multiplier applied above the target usage to derive the heap size. Example: 1.3. + :param pulumi.Input[_builtins.int] max_heap_bytes: Maximum JVM heap size in bytes. Example: 2147483648. + :param pulumi.Input[_builtins.int] min_heap_bytes: Minimum JVM heap size in bytes. Example: 134217728. + :param pulumi.Input[_builtins.int] non_heap_overhead_bytes: Non-heap memory overhead in bytes. Takes precedence over nonHeapOverheadPercent when set. Example: 268435456. + :param pulumi.Input[_builtins.float] non_heap_overhead_percent: Non-heap memory overhead as a percentage of container memory (0-1). Example: 0.2. + :param pulumi.Input[_builtins.bool] prefer_container_support: Prefer the JVM's native container-aware heap sizing (-XX:+UseContainerSupport) over explicit -Xmx/-Xms flags. Example: false. + :param pulumi.Input[_builtins.float] target_percentile: Percentile of usage data used as the heap sizing target (0-1). Example: 0.95. """ - if cluster_dns is not None: - pulumi.set(__self__, "cluster_dns", cluster_dns) - if cpu_cfs_quota is not None: - pulumi.set(__self__, "cpu_cfs_quota", cpu_cfs_quota) - if eviction_hard is not None: - pulumi.set(__self__, "eviction_hard", eviction_hard) - if eviction_max_pod_grace_period is not None: - pulumi.set(__self__, "eviction_max_pod_grace_period", eviction_max_pod_grace_period) - if eviction_soft is not None: - pulumi.set(__self__, "eviction_soft", eviction_soft) - if eviction_soft_grace_period is not None: - pulumi.set(__self__, "eviction_soft_grace_period", eviction_soft_grace_period) - if image_gc_high_threshold_percent is not None: - pulumi.set(__self__, "image_gc_high_threshold_percent", image_gc_high_threshold_percent) - if image_gc_low_threshold_percent is not None: - pulumi.set(__self__, "image_gc_low_threshold_percent", image_gc_low_threshold_percent) - if kube_reserved is not None: - pulumi.set(__self__, "kube_reserved", kube_reserved) - if max_pods is not None: - pulumi.set(__self__, "max_pods", max_pods) - if pods_per_core is not None: - pulumi.set(__self__, "pods_per_core", pods_per_core) - if system_reserved is not None: - pulumi.set(__self__, "system_reserved", system_reserved) + if enabled is not None: + pulumi.set(__self__, "enabled", enabled) + if headroom_multiplier is not None: + pulumi.set(__self__, "headroom_multiplier", headroom_multiplier) + if max_heap_bytes is not None: + pulumi.set(__self__, "max_heap_bytes", max_heap_bytes) + if min_heap_bytes is not None: + pulumi.set(__self__, "min_heap_bytes", min_heap_bytes) + if non_heap_overhead_bytes is not None: + pulumi.set(__self__, "non_heap_overhead_bytes", non_heap_overhead_bytes) + if non_heap_overhead_percent is not None: + pulumi.set(__self__, "non_heap_overhead_percent", non_heap_overhead_percent) + if prefer_container_support is not None: + pulumi.set(__self__, "prefer_container_support", prefer_container_support) + if target_percentile is not None: + pulumi.set(__self__, "target_percentile", target_percentile) @_builtins.property - @pulumi.getter(name="clusterDns") - def cluster_dns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + @pulumi.getter + def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: """ - DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. + Enable JVM heap sizing overrides. Example: true. """ - return pulumi.get(self, "cluster_dns") + return pulumi.get(self, "enabled") - @cluster_dns.setter - def cluster_dns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): - pulumi.set(self, "cluster_dns", value) + @enabled.setter + def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "enabled", value) @_builtins.property - @pulumi.getter(name="cpuCfsQuota") - def cpu_cfs_quota(self) -> Optional[pulumi.Input[_builtins.bool]]: + @pulumi.getter(name="headroomMultiplier") + def headroom_multiplier(self) -> Optional[pulumi.Input[_builtins.float]]: """ - Whether to enforce CPU CFS quota limits for containers. Example: true. + Multiplier applied above the target usage to derive the heap size. Example: 1.3. """ - return pulumi.get(self, "cpu_cfs_quota") + return pulumi.get(self, "headroom_multiplier") - @cpu_cfs_quota.setter - def cpu_cfs_quota(self, value: Optional[pulumi.Input[_builtins.bool]]): - pulumi.set(self, "cpu_cfs_quota", value) + @headroom_multiplier.setter + def headroom_multiplier(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "headroom_multiplier", value) @_builtins.property - @pulumi.getter(name="evictionHard") - def eviction_hard(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + @pulumi.getter(name="maxHeapBytes") + def max_heap_bytes(self) -> Optional[pulumi.Input[_builtins.int]]: """ - Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. + Maximum JVM heap size in bytes. Example: 2147483648. """ - return pulumi.get(self, "eviction_hard") + return pulumi.get(self, "max_heap_bytes") - @eviction_hard.setter - def eviction_hard(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): - pulumi.set(self, "eviction_hard", value) + @max_heap_bytes.setter + def max_heap_bytes(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "max_heap_bytes", value) @_builtins.property - @pulumi.getter(name="evictionMaxPodGracePeriod") - def eviction_max_pod_grace_period(self) -> Optional[pulumi.Input[_builtins.int]]: + @pulumi.getter(name="minHeapBytes") + def min_heap_bytes(self) -> Optional[pulumi.Input[_builtins.int]]: """ - Maximum pod termination grace period (seconds) during eviction. Example: 90. + Minimum JVM heap size in bytes. Example: 134217728. """ - return pulumi.get(self, "eviction_max_pod_grace_period") + return pulumi.get(self, "min_heap_bytes") - @eviction_max_pod_grace_period.setter - def eviction_max_pod_grace_period(self, value: Optional[pulumi.Input[_builtins.int]]): - pulumi.set(self, "eviction_max_pod_grace_period", value) + @min_heap_bytes.setter + def min_heap_bytes(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "min_heap_bytes", value) @_builtins.property - @pulumi.getter(name="evictionSoft") - def eviction_soft(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + @pulumi.getter(name="nonHeapOverheadBytes") + def non_heap_overhead_bytes(self) -> Optional[pulumi.Input[_builtins.int]]: """ - Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. + Non-heap memory overhead in bytes. Takes precedence over nonHeapOverheadPercent when set. Example: 268435456. """ - return pulumi.get(self, "eviction_soft") + return pulumi.get(self, "non_heap_overhead_bytes") - @eviction_soft.setter - def eviction_soft(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): - pulumi.set(self, "eviction_soft", value) + @non_heap_overhead_bytes.setter + def non_heap_overhead_bytes(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "non_heap_overhead_bytes", value) @_builtins.property - @pulumi.getter(name="evictionSoftGracePeriod") - def eviction_soft_grace_period(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + @pulumi.getter(name="nonHeapOverheadPercent") + def non_heap_overhead_percent(self) -> Optional[pulumi.Input[_builtins.float]]: """ - Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. + Non-heap memory overhead as a percentage of container memory (0-1). Example: 0.2. """ - return pulumi.get(self, "eviction_soft_grace_period") + return pulumi.get(self, "non_heap_overhead_percent") - @eviction_soft_grace_period.setter - def eviction_soft_grace_period(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): - pulumi.set(self, "eviction_soft_grace_period", value) + @non_heap_overhead_percent.setter + def non_heap_overhead_percent(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "non_heap_overhead_percent", value) @_builtins.property - @pulumi.getter(name="imageGcHighThresholdPercent") - def image_gc_high_threshold_percent(self) -> Optional[pulumi.Input[_builtins.int]]: + @pulumi.getter(name="preferContainerSupport") + def prefer_container_support(self) -> Optional[pulumi.Input[_builtins.bool]]: """ - Disk usage % that triggers image garbage collection. Example: 85. + Prefer the JVM's native container-aware heap sizing (-XX:+UseContainerSupport) over explicit -Xmx/-Xms flags. Example: false. """ - return pulumi.get(self, "image_gc_high_threshold_percent") + return pulumi.get(self, "prefer_container_support") - @image_gc_high_threshold_percent.setter - def image_gc_high_threshold_percent(self, value: Optional[pulumi.Input[_builtins.int]]): - pulumi.set(self, "image_gc_high_threshold_percent", value) + @prefer_container_support.setter + def prefer_container_support(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "prefer_container_support", value) @_builtins.property - @pulumi.getter(name="imageGcLowThresholdPercent") - def image_gc_low_threshold_percent(self) -> Optional[pulumi.Input[_builtins.int]]: + @pulumi.getter(name="targetPercentile") + def target_percentile(self) -> Optional[pulumi.Input[_builtins.float]]: """ - Disk usage % at which image GC stops freeing space. Example: 70. + Percentile of usage data used as the heap sizing target (0-1). Example: 0.95. """ - return pulumi.get(self, "image_gc_low_threshold_percent") + return pulumi.get(self, "target_percentile") - @image_gc_low_threshold_percent.setter - def image_gc_low_threshold_percent(self, value: Optional[pulumi.Input[_builtins.int]]): - pulumi.set(self, "image_gc_low_threshold_percent", value) + @target_percentile.setter + def target_percentile(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "target_percentile", value) - @_builtins.property - @pulumi.getter(name="kubeReserved") - def kube_reserved(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: - """ - Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. - """ - return pulumi.get(self, "kube_reserved") - @kube_reserved.setter - def kube_reserved(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): - pulumi.set(self, "kube_reserved", value) +class KedaAdvancedArgsArgsDict(TypedDict): + advanced_behavior_json: NotRequired[pulumi.Input[_builtins.str]] + """ + Kubernetes HorizontalPodAutoscalerBehavior encoded as a JSON string, applied to the generated HPA. Example: '{"scaleDown":{"stabilizationWindowSeconds":300}}'. + """ + restore_to_original_replica_count: NotRequired[pulumi.Input[_builtins.bool]] + """ + Restore the original replica count when the ScaledObject is deleted. Example: false. + """ - @_builtins.property - @pulumi.getter(name="maxPods") - def max_pods(self) -> Optional[pulumi.Input[_builtins.int]]: +@pulumi.input_type +class KedaAdvancedArgsArgs: + def __init__(__self__, *, + advanced_behavior_json: Optional[pulumi.Input[_builtins.str]] = None, + restore_to_original_replica_count: Optional[pulumi.Input[_builtins.bool]] = None): """ - Maximum number of pods allowed per node. Example: 110. + :param pulumi.Input[_builtins.str] advanced_behavior_json: Kubernetes HorizontalPodAutoscalerBehavior encoded as a JSON string, applied to the generated HPA. Example: '{"scaleDown":{"stabilizationWindowSeconds":300}}'. + :param pulumi.Input[_builtins.bool] restore_to_original_replica_count: Restore the original replica count when the ScaledObject is deleted. Example: false. """ - return pulumi.get(self, "max_pods") - - @max_pods.setter - def max_pods(self, value: Optional[pulumi.Input[_builtins.int]]): - pulumi.set(self, "max_pods", value) + if advanced_behavior_json is not None: + pulumi.set(__self__, "advanced_behavior_json", advanced_behavior_json) + if restore_to_original_replica_count is not None: + pulumi.set(__self__, "restore_to_original_replica_count", restore_to_original_replica_count) @_builtins.property - @pulumi.getter(name="podsPerCore") - def pods_per_core(self) -> Optional[pulumi.Input[_builtins.int]]: + @pulumi.getter(name="advancedBehaviorJson") + def advanced_behavior_json(self) -> Optional[pulumi.Input[_builtins.str]]: """ - Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. + Kubernetes HorizontalPodAutoscalerBehavior encoded as a JSON string, applied to the generated HPA. Example: '{"scaleDown":{"stabilizationWindowSeconds":300}}'. """ - return pulumi.get(self, "pods_per_core") + return pulumi.get(self, "advanced_behavior_json") - @pods_per_core.setter - def pods_per_core(self, value: Optional[pulumi.Input[_builtins.int]]): - pulumi.set(self, "pods_per_core", value) + @advanced_behavior_json.setter + def advanced_behavior_json(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "advanced_behavior_json", value) @_builtins.property - @pulumi.getter(name="systemReserved") - def system_reserved(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + @pulumi.getter(name="restoreToOriginalReplicaCount") + def restore_to_original_replica_count(self) -> Optional[pulumi.Input[_builtins.bool]]: """ - Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. + Restore the original replica count when the ScaledObject is deleted. Example: false. """ - return pulumi.get(self, "system_reserved") + return pulumi.get(self, "restore_to_original_replica_count") - @system_reserved.setter - def system_reserved(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): - pulumi.set(self, "system_reserved", value) + @restore_to_original_replica_count.setter + def restore_to_original_replica_count(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "restore_to_original_replica_count", value) -class LabelSelectorArgsArgsDict(TypedDict): - match_expressions: NotRequired[pulumi.Input[Sequence[pulumi.Input['LabelSelectorRequirementArgsArgsDict']]]] +class KedaAuthenticationRefArgsArgsDict(TypedDict): + name: pulumi.Input[_builtins.str] """ - List of label selector requirements joined by AND. + Name of the referenced TriggerAuthentication/ClusterTriggerAuthentication resource. Example: 'prometheus-auth'. """ - match_labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + kind: NotRequired[pulumi.Input[_builtins.str]] """ - Map of label key-value pairs that must all match exactly. + Kind of the referenced resource. One of: 'TriggerAuthentication', 'ClusterTriggerAuthentication'. Example: 'TriggerAuthentication'. """ @pulumi.input_type -class LabelSelectorArgsArgs: +class KedaAuthenticationRefArgsArgs: def __init__(__self__, *, - match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['LabelSelectorRequirementArgsArgs']]]] = None, - match_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None): + name: pulumi.Input[_builtins.str], + kind: Optional[pulumi.Input[_builtins.str]] = None): """ - :param pulumi.Input[Sequence[pulumi.Input['LabelSelectorRequirementArgsArgs']]] match_expressions: List of label selector requirements joined by AND. - :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] match_labels: Map of label key-value pairs that must all match exactly. + :param pulumi.Input[_builtins.str] name: Name of the referenced TriggerAuthentication/ClusterTriggerAuthentication resource. Example: 'prometheus-auth'. + :param pulumi.Input[_builtins.str] kind: Kind of the referenced resource. One of: 'TriggerAuthentication', 'ClusterTriggerAuthentication'. Example: 'TriggerAuthentication'. """ - if match_expressions is not None: - pulumi.set(__self__, "match_expressions", match_expressions) - if match_labels is not None: - pulumi.set(__self__, "match_labels", match_labels) + pulumi.set(__self__, "name", name) + if kind is not None: + pulumi.set(__self__, "kind", kind) @_builtins.property - @pulumi.getter(name="matchExpressions") - def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LabelSelectorRequirementArgsArgs']]]]: + @pulumi.getter + def name(self) -> pulumi.Input[_builtins.str]: """ - List of label selector requirements joined by AND. + Name of the referenced TriggerAuthentication/ClusterTriggerAuthentication resource. Example: 'prometheus-auth'. """ - return pulumi.get(self, "match_expressions") + return pulumi.get(self, "name") - @match_expressions.setter - def match_expressions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LabelSelectorRequirementArgsArgs']]]]): - pulumi.set(self, "match_expressions", value) + @name.setter + def name(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "name", value) @_builtins.property - @pulumi.getter(name="matchLabels") - def match_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + @pulumi.getter + def kind(self) -> Optional[pulumi.Input[_builtins.str]]: """ - Map of label key-value pairs that must all match exactly. + Kind of the referenced resource. One of: 'TriggerAuthentication', 'ClusterTriggerAuthentication'. Example: 'TriggerAuthentication'. """ - return pulumi.get(self, "match_labels") + return pulumi.get(self, "kind") - @match_labels.setter - def match_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): - pulumi.set(self, "match_labels", value) + @kind.setter + def kind(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "kind", value) -class LabelSelectorRequirementArgsArgsDict(TypedDict): - key: NotRequired[pulumi.Input[_builtins.str]] +class KedaFallbackArgsArgsDict(TypedDict): + failure_threshold: pulumi.Input[_builtins.int] """ - The label key that the selector applies to. + Number of consecutive metric failures before activating fallback. Example: 3. """ - operator: NotRequired[pulumi.Input[_builtins.str]] + replicas: pulumi.Input[_builtins.int] """ - Operator relating the key and values. One of: 'In', 'NotIn', 'Exists', 'DoesNotExist'. + Number of replicas to fall back to when metrics are unavailable. Example: 2. """ - values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + behavior: NotRequired[pulumi.Input[_builtins.str]] """ - Array of string values. Required for 'In' and 'NotIn' operators. + Fallback strategy. Example: 'static'. """ @pulumi.input_type -class LabelSelectorRequirementArgsArgs: +class KedaFallbackArgsArgs: def __init__(__self__, *, - key: Optional[pulumi.Input[_builtins.str]] = None, - operator: Optional[pulumi.Input[_builtins.str]] = None, - values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + failure_threshold: pulumi.Input[_builtins.int], + replicas: pulumi.Input[_builtins.int], + behavior: Optional[pulumi.Input[_builtins.str]] = None): """ - :param pulumi.Input[_builtins.str] key: The label key that the selector applies to. - :param pulumi.Input[_builtins.str] operator: Operator relating the key and values. One of: 'In', 'NotIn', 'Exists', 'DoesNotExist'. - :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: Array of string values. Required for 'In' and 'NotIn' operators. + :param pulumi.Input[_builtins.int] failure_threshold: Number of consecutive metric failures before activating fallback. Example: 3. + :param pulumi.Input[_builtins.int] replicas: Number of replicas to fall back to when metrics are unavailable. Example: 2. + :param pulumi.Input[_builtins.str] behavior: Fallback strategy. Example: 'static'. """ - if key is not None: - pulumi.set(__self__, "key", key) - if operator is not None: - pulumi.set(__self__, "operator", operator) - if values is not None: - pulumi.set(__self__, "values", values) + pulumi.set(__self__, "failure_threshold", failure_threshold) + pulumi.set(__self__, "replicas", replicas) + if behavior is not None: + pulumi.set(__self__, "behavior", behavior) @_builtins.property - @pulumi.getter - def key(self) -> Optional[pulumi.Input[_builtins.str]]: + @pulumi.getter(name="failureThreshold") + def failure_threshold(self) -> pulumi.Input[_builtins.int]: """ - The label key that the selector applies to. + Number of consecutive metric failures before activating fallback. Example: 3. """ - return pulumi.get(self, "key") + return pulumi.get(self, "failure_threshold") - @key.setter - def key(self, value: Optional[pulumi.Input[_builtins.str]]): - pulumi.set(self, "key", value) + @failure_threshold.setter + def failure_threshold(self, value: pulumi.Input[_builtins.int]): + pulumi.set(self, "failure_threshold", value) @_builtins.property @pulumi.getter - def operator(self) -> Optional[pulumi.Input[_builtins.str]]: + def replicas(self) -> pulumi.Input[_builtins.int]: """ - Operator relating the key and values. One of: 'In', 'NotIn', 'Exists', 'DoesNotExist'. + Number of replicas to fall back to when metrics are unavailable. Example: 2. """ - return pulumi.get(self, "operator") + return pulumi.get(self, "replicas") - @operator.setter - def operator(self, value: Optional[pulumi.Input[_builtins.str]]): - pulumi.set(self, "operator", value) + @replicas.setter + def replicas(self, value: pulumi.Input[_builtins.int]): + pulumi.set(self, "replicas", value) @_builtins.property @pulumi.getter - def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + def behavior(self) -> Optional[pulumi.Input[_builtins.str]]: """ - Array of string values. Required for 'In' and 'NotIn' operators. + Fallback strategy. Example: 'static'. """ - return pulumi.get(self, "values") + return pulumi.get(self, "behavior") - @values.setter - def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): - pulumi.set(self, "values", value) + @behavior.setter + def behavior(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "behavior", value) -class MetadataOptionsArgsArgsDict(TypedDict): - http_endpoint: NotRequired[pulumi.Input[_builtins.str]] +class KedaScaledObjectArgsArgsDict(TypedDict): + advanced: NotRequired[pulumi.Input['KedaAdvancedArgsArgsDict']] """ - Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. + Advanced ScaledObject behavior configuration. """ - http_protocol_ipv6: NotRequired[pulumi.Input[_builtins.str]] + cooldown_period: NotRequired[pulumi.Input[_builtins.int]] """ - Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. + Seconds to wait after the last trigger reports active=false before scaling to minReplicaCount. Example: 300. """ - http_put_response_hop_limit: NotRequired[pulumi.Input[_builtins.int]] + fallback: NotRequired[pulumi.Input['KedaFallbackArgsArgsDict']] """ - HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. + Replica fallback configuration when KEDA metrics are unavailable. """ - http_tokens: NotRequired[pulumi.Input[_builtins.str]] + idle_replica_count: NotRequired[pulumi.Input[_builtins.int]] """ - Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. + Replica count to scale to when idle. Must be less than minReplicaCount. Example: 0. + """ + initial_cooldown_period: NotRequired[pulumi.Input[_builtins.int]] + """ + Cooldown period applied only during the initial scaling of the ScaledObject. Example: 0. + """ + max_replica_count: NotRequired[pulumi.Input[_builtins.int]] + """ + Maximum number of replicas. Example: 10. + """ + min_replica_count: NotRequired[pulumi.Input[_builtins.int]] + """ + Minimum number of replicas. Example: 0. + """ + polling_interval: NotRequired[pulumi.Input[_builtins.int]] + """ + Seconds between checks of trigger metrics. Example: 30. + """ + triggers: NotRequired[pulumi.Input[Sequence[pulumi.Input['KedaTriggerArgsArgsDict']]]] + """ + KEDA scaler triggers driving this ScaledObject. """ @pulumi.input_type -class MetadataOptionsArgsArgs: +class KedaScaledObjectArgsArgs: def __init__(__self__, *, - http_endpoint: Optional[pulumi.Input[_builtins.str]] = None, - http_protocol_ipv6: Optional[pulumi.Input[_builtins.str]] = None, - http_put_response_hop_limit: Optional[pulumi.Input[_builtins.int]] = None, - http_tokens: Optional[pulumi.Input[_builtins.str]] = None): + advanced: Optional[pulumi.Input['KedaAdvancedArgsArgs']] = None, + cooldown_period: Optional[pulumi.Input[_builtins.int]] = None, + fallback: Optional[pulumi.Input['KedaFallbackArgsArgs']] = None, + idle_replica_count: Optional[pulumi.Input[_builtins.int]] = None, + initial_cooldown_period: Optional[pulumi.Input[_builtins.int]] = None, + max_replica_count: Optional[pulumi.Input[_builtins.int]] = None, + min_replica_count: Optional[pulumi.Input[_builtins.int]] = None, + polling_interval: Optional[pulumi.Input[_builtins.int]] = None, + triggers: Optional[pulumi.Input[Sequence[pulumi.Input['KedaTriggerArgsArgs']]]] = None): + """ + :param pulumi.Input['KedaAdvancedArgsArgs'] advanced: Advanced ScaledObject behavior configuration. + :param pulumi.Input[_builtins.int] cooldown_period: Seconds to wait after the last trigger reports active=false before scaling to minReplicaCount. Example: 300. + :param pulumi.Input['KedaFallbackArgsArgs'] fallback: Replica fallback configuration when KEDA metrics are unavailable. + :param pulumi.Input[_builtins.int] idle_replica_count: Replica count to scale to when idle. Must be less than minReplicaCount. Example: 0. + :param pulumi.Input[_builtins.int] initial_cooldown_period: Cooldown period applied only during the initial scaling of the ScaledObject. Example: 0. + :param pulumi.Input[_builtins.int] max_replica_count: Maximum number of replicas. Example: 10. + :param pulumi.Input[_builtins.int] min_replica_count: Minimum number of replicas. Example: 0. + :param pulumi.Input[_builtins.int] polling_interval: Seconds between checks of trigger metrics. Example: 30. + :param pulumi.Input[Sequence[pulumi.Input['KedaTriggerArgsArgs']]] triggers: KEDA scaler triggers driving this ScaledObject. + """ + if advanced is not None: + pulumi.set(__self__, "advanced", advanced) + if cooldown_period is not None: + pulumi.set(__self__, "cooldown_period", cooldown_period) + if fallback is not None: + pulumi.set(__self__, "fallback", fallback) + if idle_replica_count is not None: + pulumi.set(__self__, "idle_replica_count", idle_replica_count) + if initial_cooldown_period is not None: + pulumi.set(__self__, "initial_cooldown_period", initial_cooldown_period) + if max_replica_count is not None: + pulumi.set(__self__, "max_replica_count", max_replica_count) + if min_replica_count is not None: + pulumi.set(__self__, "min_replica_count", min_replica_count) + if polling_interval is not None: + pulumi.set(__self__, "polling_interval", polling_interval) + if triggers is not None: + pulumi.set(__self__, "triggers", triggers) + + @_builtins.property + @pulumi.getter + def advanced(self) -> Optional[pulumi.Input['KedaAdvancedArgsArgs']]: """ - :param pulumi.Input[_builtins.str] http_endpoint: Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. - :param pulumi.Input[_builtins.str] http_protocol_ipv6: Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. - :param pulumi.Input[_builtins.int] http_put_response_hop_limit: HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. - :param pulumi.Input[_builtins.str] http_tokens: Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. + Advanced ScaledObject behavior configuration. """ - if http_endpoint is not None: - pulumi.set(__self__, "http_endpoint", http_endpoint) - if http_protocol_ipv6 is not None: + return pulumi.get(self, "advanced") + + @advanced.setter + def advanced(self, value: Optional[pulumi.Input['KedaAdvancedArgsArgs']]): + pulumi.set(self, "advanced", value) + + @_builtins.property + @pulumi.getter(name="cooldownPeriod") + def cooldown_period(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Seconds to wait after the last trigger reports active=false before scaling to minReplicaCount. Example: 300. + """ + return pulumi.get(self, "cooldown_period") + + @cooldown_period.setter + def cooldown_period(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "cooldown_period", value) + + @_builtins.property + @pulumi.getter + def fallback(self) -> Optional[pulumi.Input['KedaFallbackArgsArgs']]: + """ + Replica fallback configuration when KEDA metrics are unavailable. + """ + return pulumi.get(self, "fallback") + + @fallback.setter + def fallback(self, value: Optional[pulumi.Input['KedaFallbackArgsArgs']]): + pulumi.set(self, "fallback", value) + + @_builtins.property + @pulumi.getter(name="idleReplicaCount") + def idle_replica_count(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Replica count to scale to when idle. Must be less than minReplicaCount. Example: 0. + """ + return pulumi.get(self, "idle_replica_count") + + @idle_replica_count.setter + def idle_replica_count(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "idle_replica_count", value) + + @_builtins.property + @pulumi.getter(name="initialCooldownPeriod") + def initial_cooldown_period(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Cooldown period applied only during the initial scaling of the ScaledObject. Example: 0. + """ + return pulumi.get(self, "initial_cooldown_period") + + @initial_cooldown_period.setter + def initial_cooldown_period(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "initial_cooldown_period", value) + + @_builtins.property + @pulumi.getter(name="maxReplicaCount") + def max_replica_count(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Maximum number of replicas. Example: 10. + """ + return pulumi.get(self, "max_replica_count") + + @max_replica_count.setter + def max_replica_count(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "max_replica_count", value) + + @_builtins.property + @pulumi.getter(name="minReplicaCount") + def min_replica_count(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Minimum number of replicas. Example: 0. + """ + return pulumi.get(self, "min_replica_count") + + @min_replica_count.setter + def min_replica_count(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "min_replica_count", value) + + @_builtins.property + @pulumi.getter(name="pollingInterval") + def polling_interval(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Seconds between checks of trigger metrics. Example: 30. + """ + return pulumi.get(self, "polling_interval") + + @polling_interval.setter + def polling_interval(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "polling_interval", value) + + @_builtins.property + @pulumi.getter + def triggers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KedaTriggerArgsArgs']]]]: + """ + KEDA scaler triggers driving this ScaledObject. + """ + return pulumi.get(self, "triggers") + + @triggers.setter + def triggers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['KedaTriggerArgsArgs']]]]): + pulumi.set(self, "triggers", value) + + +class KedaTriggerArgsArgsDict(TypedDict): + type: pulumi.Input[_builtins.str] + """ + KEDA scaler type. Example: 'prometheus'. + """ + authentication_ref: NotRequired[pulumi.Input['KedaAuthenticationRefArgsArgsDict']] + """ + Reference to a TriggerAuthentication or ClusterTriggerAuthentication for this trigger. + """ + metadata: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + """ + Scaler-specific configuration key-value pairs. Example: {"serverAddress": "http://prometheus:9090", "query": "sum(rate(http_requests_total[2m]))"}. + """ + metric_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Metric target type. One of: 'Value', 'AverageValue', 'Utilization'. Example: 'AverageValue'. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Optional trigger name, used to disambiguate multiple triggers of the same type. Example: 'requests-per-second'. + """ + use_cached_metrics: NotRequired[pulumi.Input[_builtins.bool]] + """ + Use KEDA's metric caching for this trigger. Example: false. + """ + +@pulumi.input_type +class KedaTriggerArgsArgs: + def __init__(__self__, *, + type: pulumi.Input[_builtins.str], + authentication_ref: Optional[pulumi.Input['KedaAuthenticationRefArgsArgs']] = None, + metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + metric_type: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + use_cached_metrics: Optional[pulumi.Input[_builtins.bool]] = None): + """ + :param pulumi.Input[_builtins.str] type: KEDA scaler type. Example: 'prometheus'. + :param pulumi.Input['KedaAuthenticationRefArgsArgs'] authentication_ref: Reference to a TriggerAuthentication or ClusterTriggerAuthentication for this trigger. + :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] metadata: Scaler-specific configuration key-value pairs. Example: {"serverAddress": "http://prometheus:9090", "query": "sum(rate(http_requests_total[2m]))"}. + :param pulumi.Input[_builtins.str] metric_type: Metric target type. One of: 'Value', 'AverageValue', 'Utilization'. Example: 'AverageValue'. + :param pulumi.Input[_builtins.str] name: Optional trigger name, used to disambiguate multiple triggers of the same type. Example: 'requests-per-second'. + :param pulumi.Input[_builtins.bool] use_cached_metrics: Use KEDA's metric caching for this trigger. Example: false. + """ + pulumi.set(__self__, "type", type) + if authentication_ref is not None: + pulumi.set(__self__, "authentication_ref", authentication_ref) + if metadata is not None: + pulumi.set(__self__, "metadata", metadata) + if metric_type is not None: + pulumi.set(__self__, "metric_type", metric_type) + if name is not None: + pulumi.set(__self__, "name", name) + if use_cached_metrics is not None: + pulumi.set(__self__, "use_cached_metrics", use_cached_metrics) + + @_builtins.property + @pulumi.getter + def type(self) -> pulumi.Input[_builtins.str]: + """ + KEDA scaler type. Example: 'prometheus'. + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "type", value) + + @_builtins.property + @pulumi.getter(name="authenticationRef") + def authentication_ref(self) -> Optional[pulumi.Input['KedaAuthenticationRefArgsArgs']]: + """ + Reference to a TriggerAuthentication or ClusterTriggerAuthentication for this trigger. + """ + return pulumi.get(self, "authentication_ref") + + @authentication_ref.setter + def authentication_ref(self, value: Optional[pulumi.Input['KedaAuthenticationRefArgsArgs']]): + pulumi.set(self, "authentication_ref", value) + + @_builtins.property + @pulumi.getter + def metadata(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + """ + Scaler-specific configuration key-value pairs. Example: {"serverAddress": "http://prometheus:9090", "query": "sum(rate(http_requests_total[2m]))"}. + """ + return pulumi.get(self, "metadata") + + @metadata.setter + def metadata(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "metadata", value) + + @_builtins.property + @pulumi.getter(name="metricType") + def metric_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Metric target type. One of: 'Value', 'AverageValue', 'Utilization'. Example: 'AverageValue'. + """ + return pulumi.get(self, "metric_type") + + @metric_type.setter + def metric_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "metric_type", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Optional trigger name, used to disambiguate multiple triggers of the same type. Example: 'requests-per-second'. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="useCachedMetrics") + def use_cached_metrics(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Use KEDA's metric caching for this trigger. Example: false. + """ + return pulumi.get(self, "use_cached_metrics") + + @use_cached_metrics.setter + def use_cached_metrics(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "use_cached_metrics", value) + + +class KubeletConfigurationArgsArgsDict(TypedDict): + cluster_dns: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. + """ + cpu_cfs_quota: NotRequired[pulumi.Input[_builtins.bool]] + """ + Whether to enforce CPU CFS quota limits for containers. Example: true. + """ + eviction_hard: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + """ + Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. + """ + eviction_max_pod_grace_period: NotRequired[pulumi.Input[_builtins.int]] + """ + Maximum pod termination grace period (seconds) during eviction. Example: 90. + """ + eviction_soft: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + """ + Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. + """ + eviction_soft_grace_period: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + """ + Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. + """ + image_gc_high_threshold_percent: NotRequired[pulumi.Input[_builtins.int]] + """ + Disk usage % that triggers image garbage collection. Example: 85. + """ + image_gc_low_threshold_percent: NotRequired[pulumi.Input[_builtins.int]] + """ + Disk usage % at which image GC stops freeing space. Example: 70. + """ + kube_reserved: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + """ + Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. + """ + max_pods: NotRequired[pulumi.Input[_builtins.int]] + """ + Maximum number of pods allowed per node. Example: 110. + """ + pods_per_core: NotRequired[pulumi.Input[_builtins.int]] + """ + Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. + """ + system_reserved: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + """ + Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. + """ + +@pulumi.input_type +class KubeletConfigurationArgsArgs: + def __init__(__self__, *, + cluster_dns: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + cpu_cfs_quota: Optional[pulumi.Input[_builtins.bool]] = None, + eviction_hard: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + eviction_max_pod_grace_period: Optional[pulumi.Input[_builtins.int]] = None, + eviction_soft: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + eviction_soft_grace_period: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + image_gc_high_threshold_percent: Optional[pulumi.Input[_builtins.int]] = None, + image_gc_low_threshold_percent: Optional[pulumi.Input[_builtins.int]] = None, + kube_reserved: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + max_pods: Optional[pulumi.Input[_builtins.int]] = None, + pods_per_core: Optional[pulumi.Input[_builtins.int]] = None, + system_reserved: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] cluster_dns: DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. + :param pulumi.Input[_builtins.bool] cpu_cfs_quota: Whether to enforce CPU CFS quota limits for containers. Example: true. + :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] eviction_hard: Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. + :param pulumi.Input[_builtins.int] eviction_max_pod_grace_period: Maximum pod termination grace period (seconds) during eviction. Example: 90. + :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] eviction_soft: Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. + :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] eviction_soft_grace_period: Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. + :param pulumi.Input[_builtins.int] image_gc_high_threshold_percent: Disk usage % that triggers image garbage collection. Example: 85. + :param pulumi.Input[_builtins.int] image_gc_low_threshold_percent: Disk usage % at which image GC stops freeing space. Example: 70. + :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] kube_reserved: Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. + :param pulumi.Input[_builtins.int] max_pods: Maximum number of pods allowed per node. Example: 110. + :param pulumi.Input[_builtins.int] pods_per_core: Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. + :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] system_reserved: Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. + """ + if cluster_dns is not None: + pulumi.set(__self__, "cluster_dns", cluster_dns) + if cpu_cfs_quota is not None: + pulumi.set(__self__, "cpu_cfs_quota", cpu_cfs_quota) + if eviction_hard is not None: + pulumi.set(__self__, "eviction_hard", eviction_hard) + if eviction_max_pod_grace_period is not None: + pulumi.set(__self__, "eviction_max_pod_grace_period", eviction_max_pod_grace_period) + if eviction_soft is not None: + pulumi.set(__self__, "eviction_soft", eviction_soft) + if eviction_soft_grace_period is not None: + pulumi.set(__self__, "eviction_soft_grace_period", eviction_soft_grace_period) + if image_gc_high_threshold_percent is not None: + pulumi.set(__self__, "image_gc_high_threshold_percent", image_gc_high_threshold_percent) + if image_gc_low_threshold_percent is not None: + pulumi.set(__self__, "image_gc_low_threshold_percent", image_gc_low_threshold_percent) + if kube_reserved is not None: + pulumi.set(__self__, "kube_reserved", kube_reserved) + if max_pods is not None: + pulumi.set(__self__, "max_pods", max_pods) + if pods_per_core is not None: + pulumi.set(__self__, "pods_per_core", pods_per_core) + if system_reserved is not None: + pulumi.set(__self__, "system_reserved", system_reserved) + + @_builtins.property + @pulumi.getter(name="clusterDns") + def cluster_dns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. + """ + return pulumi.get(self, "cluster_dns") + + @cluster_dns.setter + def cluster_dns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "cluster_dns", value) + + @_builtins.property + @pulumi.getter(name="cpuCfsQuota") + def cpu_cfs_quota(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Whether to enforce CPU CFS quota limits for containers. Example: true. + """ + return pulumi.get(self, "cpu_cfs_quota") + + @cpu_cfs_quota.setter + def cpu_cfs_quota(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "cpu_cfs_quota", value) + + @_builtins.property + @pulumi.getter(name="evictionHard") + def eviction_hard(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + """ + Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. + """ + return pulumi.get(self, "eviction_hard") + + @eviction_hard.setter + def eviction_hard(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "eviction_hard", value) + + @_builtins.property + @pulumi.getter(name="evictionMaxPodGracePeriod") + def eviction_max_pod_grace_period(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Maximum pod termination grace period (seconds) during eviction. Example: 90. + """ + return pulumi.get(self, "eviction_max_pod_grace_period") + + @eviction_max_pod_grace_period.setter + def eviction_max_pod_grace_period(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "eviction_max_pod_grace_period", value) + + @_builtins.property + @pulumi.getter(name="evictionSoft") + def eviction_soft(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + """ + Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. + """ + return pulumi.get(self, "eviction_soft") + + @eviction_soft.setter + def eviction_soft(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "eviction_soft", value) + + @_builtins.property + @pulumi.getter(name="evictionSoftGracePeriod") + def eviction_soft_grace_period(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + """ + Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. + """ + return pulumi.get(self, "eviction_soft_grace_period") + + @eviction_soft_grace_period.setter + def eviction_soft_grace_period(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "eviction_soft_grace_period", value) + + @_builtins.property + @pulumi.getter(name="imageGcHighThresholdPercent") + def image_gc_high_threshold_percent(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Disk usage % that triggers image garbage collection. Example: 85. + """ + return pulumi.get(self, "image_gc_high_threshold_percent") + + @image_gc_high_threshold_percent.setter + def image_gc_high_threshold_percent(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "image_gc_high_threshold_percent", value) + + @_builtins.property + @pulumi.getter(name="imageGcLowThresholdPercent") + def image_gc_low_threshold_percent(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Disk usage % at which image GC stops freeing space. Example: 70. + """ + return pulumi.get(self, "image_gc_low_threshold_percent") + + @image_gc_low_threshold_percent.setter + def image_gc_low_threshold_percent(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "image_gc_low_threshold_percent", value) + + @_builtins.property + @pulumi.getter(name="kubeReserved") + def kube_reserved(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + """ + Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. + """ + return pulumi.get(self, "kube_reserved") + + @kube_reserved.setter + def kube_reserved(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "kube_reserved", value) + + @_builtins.property + @pulumi.getter(name="maxPods") + def max_pods(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Maximum number of pods allowed per node. Example: 110. + """ + return pulumi.get(self, "max_pods") + + @max_pods.setter + def max_pods(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "max_pods", value) + + @_builtins.property + @pulumi.getter(name="podsPerCore") + def pods_per_core(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. + """ + return pulumi.get(self, "pods_per_core") + + @pods_per_core.setter + def pods_per_core(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "pods_per_core", value) + + @_builtins.property + @pulumi.getter(name="systemReserved") + def system_reserved(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + """ + Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. + """ + return pulumi.get(self, "system_reserved") + + @system_reserved.setter + def system_reserved(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "system_reserved", value) + + +class LabelSelectorArgsArgsDict(TypedDict): + match_expressions: NotRequired[pulumi.Input[Sequence[pulumi.Input['LabelSelectorRequirementArgsArgsDict']]]] + """ + List of label selector requirements joined by AND. + """ + match_labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + """ + Map of label key-value pairs that must all match exactly. + """ + +@pulumi.input_type +class LabelSelectorArgsArgs: + def __init__(__self__, *, + match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['LabelSelectorRequirementArgsArgs']]]] = None, + match_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['LabelSelectorRequirementArgsArgs']]] match_expressions: List of label selector requirements joined by AND. + :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] match_labels: Map of label key-value pairs that must all match exactly. + """ + if match_expressions is not None: + pulumi.set(__self__, "match_expressions", match_expressions) + if match_labels is not None: + pulumi.set(__self__, "match_labels", match_labels) + + @_builtins.property + @pulumi.getter(name="matchExpressions") + def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LabelSelectorRequirementArgsArgs']]]]: + """ + List of label selector requirements joined by AND. + """ + return pulumi.get(self, "match_expressions") + + @match_expressions.setter + def match_expressions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LabelSelectorRequirementArgsArgs']]]]): + pulumi.set(self, "match_expressions", value) + + @_builtins.property + @pulumi.getter(name="matchLabels") + def match_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + """ + Map of label key-value pairs that must all match exactly. + """ + return pulumi.get(self, "match_labels") + + @match_labels.setter + def match_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "match_labels", value) + + +class LabelSelectorRequirementArgsArgsDict(TypedDict): + key: NotRequired[pulumi.Input[_builtins.str]] + """ + The label key that the selector applies to. + """ + operator: NotRequired[pulumi.Input[_builtins.str]] + """ + Operator relating the key and values. One of: 'In', 'NotIn', 'Exists', 'DoesNotExist'. + """ + values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Array of string values. Required for 'In' and 'NotIn' operators. + """ + +@pulumi.input_type +class LabelSelectorRequirementArgsArgs: + def __init__(__self__, *, + key: Optional[pulumi.Input[_builtins.str]] = None, + operator: Optional[pulumi.Input[_builtins.str]] = None, + values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + :param pulumi.Input[_builtins.str] key: The label key that the selector applies to. + :param pulumi.Input[_builtins.str] operator: Operator relating the key and values. One of: 'In', 'NotIn', 'Exists', 'DoesNotExist'. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: Array of string values. Required for 'In' and 'NotIn' operators. + """ + if key is not None: + pulumi.set(__self__, "key", key) + if operator is not None: + pulumi.set(__self__, "operator", operator) + if values is not None: + pulumi.set(__self__, "values", values) + + @_builtins.property + @pulumi.getter + def key(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + The label key that the selector applies to. + """ + return pulumi.get(self, "key") + + @key.setter + def key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "key", value) + + @_builtins.property + @pulumi.getter + def operator(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Operator relating the key and values. One of: 'In', 'NotIn', 'Exists', 'DoesNotExist'. + """ + return pulumi.get(self, "operator") + + @operator.setter + def operator(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "operator", value) + + @_builtins.property + @pulumi.getter + def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Array of string values. Required for 'In' and 'NotIn' operators. + """ + return pulumi.get(self, "values") + + @values.setter + def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "values", value) + + +class MetadataOptionsArgsArgsDict(TypedDict): + http_endpoint: NotRequired[pulumi.Input[_builtins.str]] + """ + Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. + """ + http_protocol_ipv6: NotRequired[pulumi.Input[_builtins.str]] + """ + Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. + """ + http_put_response_hop_limit: NotRequired[pulumi.Input[_builtins.int]] + """ + HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. + """ + http_tokens: NotRequired[pulumi.Input[_builtins.str]] + """ + Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. + """ + +@pulumi.input_type +class MetadataOptionsArgsArgs: + def __init__(__self__, *, + http_endpoint: Optional[pulumi.Input[_builtins.str]] = None, + http_protocol_ipv6: Optional[pulumi.Input[_builtins.str]] = None, + http_put_response_hop_limit: Optional[pulumi.Input[_builtins.int]] = None, + http_tokens: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] http_endpoint: Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. + :param pulumi.Input[_builtins.str] http_protocol_ipv6: Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. + :param pulumi.Input[_builtins.int] http_put_response_hop_limit: HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. + :param pulumi.Input[_builtins.str] http_tokens: Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. + """ + if http_endpoint is not None: + pulumi.set(__self__, "http_endpoint", http_endpoint) + if http_protocol_ipv6 is not None: pulumi.set(__self__, "http_protocol_ipv6", http_protocol_ipv6) if http_put_response_hop_limit is not None: pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit) @@ -2901,101 +3910,764 @@ def __init__(__self__, *, pulumi.set(__self__, "http_tokens", http_tokens) @_builtins.property - @pulumi.getter(name="httpEndpoint") - def http_endpoint(self) -> Optional[pulumi.Input[_builtins.str]]: + @pulumi.getter(name="httpEndpoint") + def http_endpoint(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. + """ + return pulumi.get(self, "http_endpoint") + + @http_endpoint.setter + def http_endpoint(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "http_endpoint", value) + + @_builtins.property + @pulumi.getter(name="httpProtocolIpv6") + def http_protocol_ipv6(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. + """ + return pulumi.get(self, "http_protocol_ipv6") + + @http_protocol_ipv6.setter + def http_protocol_ipv6(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "http_protocol_ipv6", value) + + @_builtins.property + @pulumi.getter(name="httpPutResponseHopLimit") + def http_put_response_hop_limit(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. + """ + return pulumi.get(self, "http_put_response_hop_limit") + + @http_put_response_hop_limit.setter + def http_put_response_hop_limit(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "http_put_response_hop_limit", value) + + @_builtins.property + @pulumi.getter(name="httpTokens") + def http_tokens(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. + """ + return pulumi.get(self, "http_tokens") + + @http_tokens.setter + def http_tokens(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "http_tokens", value) + + +class NamePatternArgsArgsDict(TypedDict): + flags: NotRequired[pulumi.Input[_builtins.str]] + """ + Optional regex flags (e.g. 'i' for case-insensitive). + """ + pattern: NotRequired[pulumi.Input[_builtins.str]] + """ + Regular expression pattern to match workload names. + """ + +@pulumi.input_type +class NamePatternArgsArgs: + def __init__(__self__, *, + flags: Optional[pulumi.Input[_builtins.str]] = None, + pattern: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] flags: Optional regex flags (e.g. 'i' for case-insensitive). + :param pulumi.Input[_builtins.str] pattern: Regular expression pattern to match workload names. + """ + if flags is not None: + pulumi.set(__self__, "flags", flags) + if pattern is not None: + pulumi.set(__self__, "pattern", pattern) + + @_builtins.property + @pulumi.getter + def flags(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Optional regex flags (e.g. 'i' for case-insensitive). + """ + return pulumi.get(self, "flags") + + @flags.setter + def flags(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "flags", value) + + @_builtins.property + @pulumi.getter + def pattern(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Regular expression pattern to match workload names. + """ + return pulumi.get(self, "pattern") + + @pattern.setter + def pattern(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pattern", value) + + +class OCIBootConfigArgsArgsDict(TypedDict): + boot_volume_size_in_gbs: NotRequired[pulumi.Input[_builtins.int]] + """ + Boot volume size in GB. Example: 100. + """ + boot_volume_vpus_per_gb: NotRequired[pulumi.Input[_builtins.int]] + """ + Boot volume performance units per GB. Example: 10. + """ + +@pulumi.input_type +class OCIBootConfigArgsArgs: + def __init__(__self__, *, + boot_volume_size_in_gbs: Optional[pulumi.Input[_builtins.int]] = None, + boot_volume_vpus_per_gb: Optional[pulumi.Input[_builtins.int]] = None): + """ + :param pulumi.Input[_builtins.int] boot_volume_size_in_gbs: Boot volume size in GB. Example: 100. + :param pulumi.Input[_builtins.int] boot_volume_vpus_per_gb: Boot volume performance units per GB. Example: 10. + """ + if boot_volume_size_in_gbs is not None: + pulumi.set(__self__, "boot_volume_size_in_gbs", boot_volume_size_in_gbs) + if boot_volume_vpus_per_gb is not None: + pulumi.set(__self__, "boot_volume_vpus_per_gb", boot_volume_vpus_per_gb) + + @_builtins.property + @pulumi.getter(name="bootVolumeSizeInGbs") + def boot_volume_size_in_gbs(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Boot volume size in GB. Example: 100. + """ + return pulumi.get(self, "boot_volume_size_in_gbs") + + @boot_volume_size_in_gbs.setter + def boot_volume_size_in_gbs(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "boot_volume_size_in_gbs", value) + + @_builtins.property + @pulumi.getter(name="bootVolumeVpusPerGb") + def boot_volume_vpus_per_gb(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Boot volume performance units per GB. Example: 10. + """ + return pulumi.get(self, "boot_volume_vpus_per_gb") + + @boot_volume_vpus_per_gb.setter + def boot_volume_vpus_per_gb(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "boot_volume_vpus_per_gb", value) + + +class OCIImageSelectorTermArgsArgsDict(TypedDict): + compartment_id: NotRequired[pulumi.Input[_builtins.str]] + """ + OCID of the compartment containing the image. Example: 'ocid1.compartment.oc1..aaaaaaaa'. + """ + id: NotRequired[pulumi.Input[_builtins.str]] + """ + Explicit OCI image OCID. Example: 'ocid1.image.oc1..aaaaaaaa'. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + OCI image display name filter. Example: 'Oracle-Linux-8.9'. + """ + +@pulumi.input_type +class OCIImageSelectorTermArgsArgs: + def __init__(__self__, *, + compartment_id: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] compartment_id: OCID of the compartment containing the image. Example: 'ocid1.compartment.oc1..aaaaaaaa'. + :param pulumi.Input[_builtins.str] id: Explicit OCI image OCID. Example: 'ocid1.image.oc1..aaaaaaaa'. + :param pulumi.Input[_builtins.str] name: OCI image display name filter. Example: 'Oracle-Linux-8.9'. + """ + if compartment_id is not None: + pulumi.set(__self__, "compartment_id", compartment_id) + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter(name="compartmentId") + def compartment_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + OCID of the compartment containing the image. Example: 'ocid1.compartment.oc1..aaaaaaaa'. + """ + return pulumi.get(self, "compartment_id") + + @compartment_id.setter + def compartment_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compartment_id", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Explicit OCI image OCID. Example: 'ocid1.image.oc1..aaaaaaaa'. + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + OCI image display name filter. Example: 'Oracle-Linux-8.9'. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +class OCILaunchOptionsArgsArgsDict(TypedDict): + boot_volume_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Emulation type for the boot volume. Example: 'PARAVIRTUALIZED'. + """ + firmware: NotRequired[pulumi.Input[_builtins.str]] + """ + Firmware used to boot the instance. Example: 'UEFI_64'. + """ + is_consistent_volume_naming_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Whether consistent volume naming is enabled for the instance. Example: true. + """ + network_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Emulation type for the network interface. Example: 'PARAVIRTUALIZED'. + """ + remote_data_volume_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Emulation type for remote data volumes. Example: 'PARAVIRTUALIZED'. + """ + +@pulumi.input_type +class OCILaunchOptionsArgsArgs: + def __init__(__self__, *, + boot_volume_type: Optional[pulumi.Input[_builtins.str]] = None, + firmware: Optional[pulumi.Input[_builtins.str]] = None, + is_consistent_volume_naming_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + network_type: Optional[pulumi.Input[_builtins.str]] = None, + remote_data_volume_type: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] boot_volume_type: Emulation type for the boot volume. Example: 'PARAVIRTUALIZED'. + :param pulumi.Input[_builtins.str] firmware: Firmware used to boot the instance. Example: 'UEFI_64'. + :param pulumi.Input[_builtins.bool] is_consistent_volume_naming_enabled: Whether consistent volume naming is enabled for the instance. Example: true. + :param pulumi.Input[_builtins.str] network_type: Emulation type for the network interface. Example: 'PARAVIRTUALIZED'. + :param pulumi.Input[_builtins.str] remote_data_volume_type: Emulation type for remote data volumes. Example: 'PARAVIRTUALIZED'. + """ + if boot_volume_type is not None: + pulumi.set(__self__, "boot_volume_type", boot_volume_type) + if firmware is not None: + pulumi.set(__self__, "firmware", firmware) + if is_consistent_volume_naming_enabled is not None: + pulumi.set(__self__, "is_consistent_volume_naming_enabled", is_consistent_volume_naming_enabled) + if network_type is not None: + pulumi.set(__self__, "network_type", network_type) + if remote_data_volume_type is not None: + pulumi.set(__self__, "remote_data_volume_type", remote_data_volume_type) + + @_builtins.property + @pulumi.getter(name="bootVolumeType") + def boot_volume_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Emulation type for the boot volume. Example: 'PARAVIRTUALIZED'. + """ + return pulumi.get(self, "boot_volume_type") + + @boot_volume_type.setter + def boot_volume_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "boot_volume_type", value) + + @_builtins.property + @pulumi.getter + def firmware(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Firmware used to boot the instance. Example: 'UEFI_64'. + """ + return pulumi.get(self, "firmware") + + @firmware.setter + def firmware(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "firmware", value) + + @_builtins.property + @pulumi.getter(name="isConsistentVolumeNamingEnabled") + def is_consistent_volume_naming_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Whether consistent volume naming is enabled for the instance. Example: true. + """ + return pulumi.get(self, "is_consistent_volume_naming_enabled") + + @is_consistent_volume_naming_enabled.setter + def is_consistent_volume_naming_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_consistent_volume_naming_enabled", value) + + @_builtins.property + @pulumi.getter(name="networkType") + def network_type(self) -> Optional[pulumi.Input[_builtins.str]]: """ - Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. + Emulation type for the network interface. Example: 'PARAVIRTUALIZED'. """ - return pulumi.get(self, "http_endpoint") + return pulumi.get(self, "network_type") - @http_endpoint.setter - def http_endpoint(self, value: Optional[pulumi.Input[_builtins.str]]): - pulumi.set(self, "http_endpoint", value) + @network_type.setter + def network_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "network_type", value) @_builtins.property - @pulumi.getter(name="httpProtocolIpv6") - def http_protocol_ipv6(self) -> Optional[pulumi.Input[_builtins.str]]: + @pulumi.getter(name="remoteDataVolumeType") + def remote_data_volume_type(self) -> Optional[pulumi.Input[_builtins.str]]: """ - Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. + Emulation type for remote data volumes. Example: 'PARAVIRTUALIZED'. """ - return pulumi.get(self, "http_protocol_ipv6") + return pulumi.get(self, "remote_data_volume_type") - @http_protocol_ipv6.setter - def http_protocol_ipv6(self, value: Optional[pulumi.Input[_builtins.str]]): - pulumi.set(self, "http_protocol_ipv6", value) + @remote_data_volume_type.setter + def remote_data_volume_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "remote_data_volume_type", value) + + +class OCINodeClassSpecArgsArgsDict(TypedDict): + agent_list: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + OCI compute instance agent plugins to enable. Example: ["Compute Instance Monitoring"]. + """ + block_devices: NotRequired[pulumi.Input[Sequence[pulumi.Input['OCIVolumeAttributesArgsArgsDict']]]] + """ + Additional block volumes attached to provisioned nodes. + """ + boot_config: NotRequired[pulumi.Input['OCIBootConfigArgsArgsDict']] + """ + Boot volume configuration for provisioned nodes. + """ + free_form_tags: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + """ + OCI free-form tags applied to all resources created by this node class. Example: {"environment": "production"}. + """ + image_family: NotRequired[pulumi.Input[_builtins.str]] + """ + OCI node image family shorthand used when no imageSelector is specified. Example: 'Oracle-Linux-8'. + """ + image_selector: NotRequired[pulumi.Input[Sequence[pulumi.Input['OCIImageSelectorTermArgsArgsDict']]]] + """ + Selectors for the images used to launch nodes. Example: [{name: "Oracle-Linux-8.9"}]. + """ + launch_options: NotRequired[pulumi.Input['OCILaunchOptionsArgsArgsDict']] + """ + Instance launch options controlling firmware and network/volume emulation type. + """ + meta_data: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + """ + OCI instance metadata applied to provisioned nodes. Example: {"ssh_authorized_keys": "ssh-rsa ..."}. + """ + pre_install_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Script executed before node bootstrap. Example: '#!/bin/bash\\necho pre-install'. + """ + security_group_selector: NotRequired[pulumi.Input[Sequence[pulumi.Input['OCISecurityGroupSelectorTermArgsArgsDict']]]] + """ + Selectors for network security groups attached to provisioned nodes. + """ + subnet_selector: NotRequired[pulumi.Input[Sequence[pulumi.Input['OCISubnetSelectorTermArgsArgsDict']]]] + """ + Selectors for the subnets nodes will be launched into. + """ + tags: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + """ + OCI defined tags applied to all resources created by this node class. + """ + user_data: NotRequired[pulumi.Input[_builtins.str]] + """ + Custom cloud-init user data merged into the node launch config (base64 or plain text). Example: '#!/bin/bash\\necho hello'. + """ + vcn_id: NotRequired[pulumi.Input[_builtins.str]] + """ + OCID of the VCN nodes will be launched into. Example: 'ocid1.vcn.oc1..aaaaaaaa'. + """ + +@pulumi.input_type +class OCINodeClassSpecArgsArgs: + def __init__(__self__, *, + agent_list: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['OCIVolumeAttributesArgsArgs']]]] = None, + boot_config: Optional[pulumi.Input['OCIBootConfigArgsArgs']] = None, + free_form_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + image_family: Optional[pulumi.Input[_builtins.str]] = None, + image_selector: Optional[pulumi.Input[Sequence[pulumi.Input['OCIImageSelectorTermArgsArgs']]]] = None, + launch_options: Optional[pulumi.Input['OCILaunchOptionsArgsArgs']] = None, + meta_data: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + pre_install_script: Optional[pulumi.Input[_builtins.str]] = None, + security_group_selector: Optional[pulumi.Input[Sequence[pulumi.Input['OCISecurityGroupSelectorTermArgsArgs']]]] = None, + subnet_selector: Optional[pulumi.Input[Sequence[pulumi.Input['OCISubnetSelectorTermArgsArgs']]]] = None, + tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + user_data: Optional[pulumi.Input[_builtins.str]] = None, + vcn_id: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] agent_list: OCI compute instance agent plugins to enable. Example: ["Compute Instance Monitoring"]. + :param pulumi.Input[Sequence[pulumi.Input['OCIVolumeAttributesArgsArgs']]] block_devices: Additional block volumes attached to provisioned nodes. + :param pulumi.Input['OCIBootConfigArgsArgs'] boot_config: Boot volume configuration for provisioned nodes. + :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] free_form_tags: OCI free-form tags applied to all resources created by this node class. Example: {"environment": "production"}. + :param pulumi.Input[_builtins.str] image_family: OCI node image family shorthand used when no imageSelector is specified. Example: 'Oracle-Linux-8'. + :param pulumi.Input[Sequence[pulumi.Input['OCIImageSelectorTermArgsArgs']]] image_selector: Selectors for the images used to launch nodes. Example: [{name: "Oracle-Linux-8.9"}]. + :param pulumi.Input['OCILaunchOptionsArgsArgs'] launch_options: Instance launch options controlling firmware and network/volume emulation type. + :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] meta_data: OCI instance metadata applied to provisioned nodes. Example: {"ssh_authorized_keys": "ssh-rsa ..."}. + :param pulumi.Input[_builtins.str] pre_install_script: Script executed before node bootstrap. Example: '#!/bin/bash\\necho pre-install'. + :param pulumi.Input[Sequence[pulumi.Input['OCISecurityGroupSelectorTermArgsArgs']]] security_group_selector: Selectors for network security groups attached to provisioned nodes. + :param pulumi.Input[Sequence[pulumi.Input['OCISubnetSelectorTermArgsArgs']]] subnet_selector: Selectors for the subnets nodes will be launched into. + :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] tags: OCI defined tags applied to all resources created by this node class. + :param pulumi.Input[_builtins.str] user_data: Custom cloud-init user data merged into the node launch config (base64 or plain text). Example: '#!/bin/bash\\necho hello'. + :param pulumi.Input[_builtins.str] vcn_id: OCID of the VCN nodes will be launched into. Example: 'ocid1.vcn.oc1..aaaaaaaa'. + """ + if agent_list is not None: + pulumi.set(__self__, "agent_list", agent_list) + if block_devices is not None: + pulumi.set(__self__, "block_devices", block_devices) + if boot_config is not None: + pulumi.set(__self__, "boot_config", boot_config) + if free_form_tags is not None: + pulumi.set(__self__, "free_form_tags", free_form_tags) + if image_family is not None: + pulumi.set(__self__, "image_family", image_family) + if image_selector is not None: + pulumi.set(__self__, "image_selector", image_selector) + if launch_options is not None: + pulumi.set(__self__, "launch_options", launch_options) + if meta_data is not None: + pulumi.set(__self__, "meta_data", meta_data) + if pre_install_script is not None: + pulumi.set(__self__, "pre_install_script", pre_install_script) + if security_group_selector is not None: + pulumi.set(__self__, "security_group_selector", security_group_selector) + if subnet_selector is not None: + pulumi.set(__self__, "subnet_selector", subnet_selector) + if tags is not None: + pulumi.set(__self__, "tags", tags) + if user_data is not None: + pulumi.set(__self__, "user_data", user_data) + if vcn_id is not None: + pulumi.set(__self__, "vcn_id", vcn_id) @_builtins.property - @pulumi.getter(name="httpPutResponseHopLimit") - def http_put_response_hop_limit(self) -> Optional[pulumi.Input[_builtins.int]]: + @pulumi.getter(name="agentList") + def agent_list(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: """ - HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. + OCI compute instance agent plugins to enable. Example: ["Compute Instance Monitoring"]. """ - return pulumi.get(self, "http_put_response_hop_limit") + return pulumi.get(self, "agent_list") - @http_put_response_hop_limit.setter - def http_put_response_hop_limit(self, value: Optional[pulumi.Input[_builtins.int]]): - pulumi.set(self, "http_put_response_hop_limit", value) + @agent_list.setter + def agent_list(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "agent_list", value) @_builtins.property - @pulumi.getter(name="httpTokens") - def http_tokens(self) -> Optional[pulumi.Input[_builtins.str]]: + @pulumi.getter(name="blockDevices") + def block_devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OCIVolumeAttributesArgsArgs']]]]: """ - Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. + Additional block volumes attached to provisioned nodes. """ - return pulumi.get(self, "http_tokens") + return pulumi.get(self, "block_devices") - @http_tokens.setter - def http_tokens(self, value: Optional[pulumi.Input[_builtins.str]]): - pulumi.set(self, "http_tokens", value) + @block_devices.setter + def block_devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OCIVolumeAttributesArgsArgs']]]]): + pulumi.set(self, "block_devices", value) + + @_builtins.property + @pulumi.getter(name="bootConfig") + def boot_config(self) -> Optional[pulumi.Input['OCIBootConfigArgsArgs']]: + """ + Boot volume configuration for provisioned nodes. + """ + return pulumi.get(self, "boot_config") + @boot_config.setter + def boot_config(self, value: Optional[pulumi.Input['OCIBootConfigArgsArgs']]): + pulumi.set(self, "boot_config", value) -class NamePatternArgsArgsDict(TypedDict): - flags: NotRequired[pulumi.Input[_builtins.str]] + @_builtins.property + @pulumi.getter(name="freeFormTags") + def free_form_tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + """ + OCI free-form tags applied to all resources created by this node class. Example: {"environment": "production"}. + """ + return pulumi.get(self, "free_form_tags") + + @free_form_tags.setter + def free_form_tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "free_form_tags", value) + + @_builtins.property + @pulumi.getter(name="imageFamily") + def image_family(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + OCI node image family shorthand used when no imageSelector is specified. Example: 'Oracle-Linux-8'. + """ + return pulumi.get(self, "image_family") + + @image_family.setter + def image_family(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "image_family", value) + + @_builtins.property + @pulumi.getter(name="imageSelector") + def image_selector(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OCIImageSelectorTermArgsArgs']]]]: + """ + Selectors for the images used to launch nodes. Example: [{name: "Oracle-Linux-8.9"}]. + """ + return pulumi.get(self, "image_selector") + + @image_selector.setter + def image_selector(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OCIImageSelectorTermArgsArgs']]]]): + pulumi.set(self, "image_selector", value) + + @_builtins.property + @pulumi.getter(name="launchOptions") + def launch_options(self) -> Optional[pulumi.Input['OCILaunchOptionsArgsArgs']]: + """ + Instance launch options controlling firmware and network/volume emulation type. + """ + return pulumi.get(self, "launch_options") + + @launch_options.setter + def launch_options(self, value: Optional[pulumi.Input['OCILaunchOptionsArgsArgs']]): + pulumi.set(self, "launch_options", value) + + @_builtins.property + @pulumi.getter(name="metaData") + def meta_data(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + """ + OCI instance metadata applied to provisioned nodes. Example: {"ssh_authorized_keys": "ssh-rsa ..."}. + """ + return pulumi.get(self, "meta_data") + + @meta_data.setter + def meta_data(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "meta_data", value) + + @_builtins.property + @pulumi.getter(name="preInstallScript") + def pre_install_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Script executed before node bootstrap. Example: '#!/bin/bash\\necho pre-install'. + """ + return pulumi.get(self, "pre_install_script") + + @pre_install_script.setter + def pre_install_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_install_script", value) + + @_builtins.property + @pulumi.getter(name="securityGroupSelector") + def security_group_selector(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OCISecurityGroupSelectorTermArgsArgs']]]]: + """ + Selectors for network security groups attached to provisioned nodes. + """ + return pulumi.get(self, "security_group_selector") + + @security_group_selector.setter + def security_group_selector(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OCISecurityGroupSelectorTermArgsArgs']]]]): + pulumi.set(self, "security_group_selector", value) + + @_builtins.property + @pulumi.getter(name="subnetSelector") + def subnet_selector(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OCISubnetSelectorTermArgsArgs']]]]: + """ + Selectors for the subnets nodes will be launched into. + """ + return pulumi.get(self, "subnet_selector") + + @subnet_selector.setter + def subnet_selector(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OCISubnetSelectorTermArgsArgs']]]]): + pulumi.set(self, "subnet_selector", value) + + @_builtins.property + @pulumi.getter + def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + """ + OCI defined tags applied to all resources created by this node class. + """ + return pulumi.get(self, "tags") + + @tags.setter + def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "tags", value) + + @_builtins.property + @pulumi.getter(name="userData") + def user_data(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Custom cloud-init user data merged into the node launch config (base64 or plain text). Example: '#!/bin/bash\\necho hello'. + """ + return pulumi.get(self, "user_data") + + @user_data.setter + def user_data(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_data", value) + + @_builtins.property + @pulumi.getter(name="vcnId") + def vcn_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + OCID of the VCN nodes will be launched into. Example: 'ocid1.vcn.oc1..aaaaaaaa'. + """ + return pulumi.get(self, "vcn_id") + + @vcn_id.setter + def vcn_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "vcn_id", value) + + +class OCISecurityGroupSelectorTermArgsArgsDict(TypedDict): + id: NotRequired[pulumi.Input[_builtins.str]] """ - Optional regex flags (e.g. 'i' for case-insensitive). + Explicit OCI network security group OCID. Example: 'ocid1.networksecuritygroup.oc1..aaaaaaaa'. """ - pattern: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] """ - Regular expression pattern to match workload names. + OCI network security group display name filter. Example: 'node-nsg'. """ @pulumi.input_type -class NamePatternArgsArgs: +class OCISecurityGroupSelectorTermArgsArgs: def __init__(__self__, *, - flags: Optional[pulumi.Input[_builtins.str]] = None, - pattern: Optional[pulumi.Input[_builtins.str]] = None): + id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None): """ - :param pulumi.Input[_builtins.str] flags: Optional regex flags (e.g. 'i' for case-insensitive). - :param pulumi.Input[_builtins.str] pattern: Regular expression pattern to match workload names. + :param pulumi.Input[_builtins.str] id: Explicit OCI network security group OCID. Example: 'ocid1.networksecuritygroup.oc1..aaaaaaaa'. + :param pulumi.Input[_builtins.str] name: OCI network security group display name filter. Example: 'node-nsg'. """ - if flags is not None: - pulumi.set(__self__, "flags", flags) - if pattern is not None: - pulumi.set(__self__, "pattern", pattern) + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) @_builtins.property @pulumi.getter - def flags(self) -> Optional[pulumi.Input[_builtins.str]]: + def id(self) -> Optional[pulumi.Input[_builtins.str]]: """ - Optional regex flags (e.g. 'i' for case-insensitive). + Explicit OCI network security group OCID. Example: 'ocid1.networksecuritygroup.oc1..aaaaaaaa'. """ - return pulumi.get(self, "flags") + return pulumi.get(self, "id") - @flags.setter - def flags(self, value: Optional[pulumi.Input[_builtins.str]]): - pulumi.set(self, "flags", value) + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) @_builtins.property @pulumi.getter - def pattern(self) -> Optional[pulumi.Input[_builtins.str]]: + def name(self) -> Optional[pulumi.Input[_builtins.str]]: """ - Regular expression pattern to match workload names. + OCI network security group display name filter. Example: 'node-nsg'. """ - return pulumi.get(self, "pattern") + return pulumi.get(self, "name") - @pattern.setter - def pattern(self, value: Optional[pulumi.Input[_builtins.str]]): - pulumi.set(self, "pattern", value) + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +class OCISubnetSelectorTermArgsArgsDict(TypedDict): + id: NotRequired[pulumi.Input[_builtins.str]] + """ + Explicit OCI subnet OCID. Example: 'ocid1.subnet.oc1..aaaaaaaa'. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + OCI subnet display name filter. Example: 'node-subnet'. + """ + +@pulumi.input_type +class OCISubnetSelectorTermArgsArgs: + def __init__(__self__, *, + id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] id: Explicit OCI subnet OCID. Example: 'ocid1.subnet.oc1..aaaaaaaa'. + :param pulumi.Input[_builtins.str] name: OCI subnet display name filter. Example: 'node-subnet'. + """ + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Explicit OCI subnet OCID. Example: 'ocid1.subnet.oc1..aaaaaaaa'. + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + OCI subnet display name filter. Example: 'node-subnet'. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +class OCIVolumeAttributesArgsArgsDict(TypedDict): + size_in_gbs: NotRequired[pulumi.Input[_builtins.int]] + """ + Block volume size in GB. Example: 50. + """ + vpus_per_gb: NotRequired[pulumi.Input[_builtins.int]] + """ + Block volume performance units per GB. Example: 10. + """ + +@pulumi.input_type +class OCIVolumeAttributesArgsArgs: + def __init__(__self__, *, + size_in_gbs: Optional[pulumi.Input[_builtins.int]] = None, + vpus_per_gb: Optional[pulumi.Input[_builtins.int]] = None): + """ + :param pulumi.Input[_builtins.int] size_in_gbs: Block volume size in GB. Example: 50. + :param pulumi.Input[_builtins.int] vpus_per_gb: Block volume performance units per GB. Example: 10. + """ + if size_in_gbs is not None: + pulumi.set(__self__, "size_in_gbs", size_in_gbs) + if vpus_per_gb is not None: + pulumi.set(__self__, "vpus_per_gb", vpus_per_gb) + + @_builtins.property + @pulumi.getter(name="sizeInGbs") + def size_in_gbs(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Block volume size in GB. Example: 50. + """ + return pulumi.get(self, "size_in_gbs") + + @size_in_gbs.setter + def size_in_gbs(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "size_in_gbs", value) + + @_builtins.property + @pulumi.getter(name="vpusPerGb") + def vpus_per_gb(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Block volume performance units per GB. Example: 10. + """ + return pulumi.get(self, "vpus_per_gb") + + @vpus_per_gb.setter + def vpus_per_gb(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "vpus_per_gb", value) class RawKarpenterSpecArgsArgsDict(TypedDict): diff --git a/sdk/python/pulumi_devzero/resources/cluster.py b/sdk/python/pulumi_devzero/resources/cluster.py index dcf9c0c..5032904 100644 --- a/sdk/python/pulumi_devzero/resources/cluster.py +++ b/sdk/python/pulumi_devzero/resources/cluster.py @@ -127,7 +127,7 @@ def name(self) -> pulumi.Output[_builtins.str]: @pulumi.getter def token(self) -> pulumi.Output[_builtins.str]: """ - Authentication token for the cluster. Rotated automatically if empty on update (e.g. after import). + Bearer token minted for the cluster at creation. Not retrievable afterwards; imported clusters have an empty token (rotate it deliberately from the DevZero UI if you need it in state). """ return pulumi.get(self, "token") diff --git a/sdk/python/pulumi_devzero/resources/node_policy.py b/sdk/python/pulumi_devzero/resources/node_policy.py index ca6d5a0..8608180 100644 --- a/sdk/python/pulumi_devzero/resources/node_policy.py +++ b/sdk/python/pulumi_devzero/resources/node_policy.py @@ -29,12 +29,16 @@ def __init__(__self__, *, cloud_provider_id: Optional[pulumi.Input[_builtins.int]] = None, description: Optional[pulumi.Input[_builtins.str]] = None, disruption: Optional[pulumi.Input['DisruptionPolicyArgsArgs']] = None, + gcp: Optional[pulumi.Input['GCPNodeClassSpecArgsArgs']] = None, instance_categories: Optional[pulumi.Input['LabelSelectorArgsArgs']] = None, instance_cpus: Optional[pulumi.Input['LabelSelectorArgsArgs']] = None, instance_families: Optional[pulumi.Input['LabelSelectorArgsArgs']] = None, instance_generations: Optional[pulumi.Input['LabelSelectorArgsArgs']] = None, instance_hypervisors: Optional[pulumi.Input['LabelSelectorArgsArgs']] = None, instance_local_nvme: Optional[pulumi.Input['LabelSelectorArgsArgs']] = None, + instance_local_nvme_tip: Optional[pulumi.Input[_builtins.str]] = None, + instance_shapes: Optional[pulumi.Input['LabelSelectorArgsArgs']] = None, + instance_shapes_tip: Optional[pulumi.Input[_builtins.str]] = None, instance_sizes: Optional[pulumi.Input['LabelSelectorArgsArgs']] = None, instance_types: Optional[pulumi.Input['LabelSelectorArgsArgs']] = None, labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, @@ -42,9 +46,11 @@ def __init__(__self__, *, master_override_role_name: Optional[pulumi.Input[_builtins.str]] = None, node_class_name: Optional[pulumi.Input[_builtins.str]] = None, node_pool_name: Optional[pulumi.Input[_builtins.str]] = None, + oci: Optional[pulumi.Input['OCINodeClassSpecArgsArgs']] = None, operating_systems: Optional[pulumi.Input['LabelSelectorArgsArgs']] = None, raw: Optional[pulumi.Input[Sequence[pulumi.Input['RawKarpenterSpecArgsArgs']]]] = None, startup_taints: Optional[pulumi.Input[Sequence[pulumi.Input['TaintArgsArgs']]]] = None, + startup_taints_tip: Optional[pulumi.Input[_builtins.str]] = None, taints: Optional[pulumi.Input[Sequence[pulumi.Input['TaintArgsArgs']]]] = None, weight: Optional[pulumi.Input[_builtins.int]] = None, zonal_shift: Optional[pulumi.Input['ZonalShiftConfigArgsArgs']] = None, @@ -67,6 +73,8 @@ def __init__(__self__, *, pulumi.set(__self__, "description", description) if disruption is not None: pulumi.set(__self__, "disruption", disruption) + if gcp is not None: + pulumi.set(__self__, "gcp", gcp) if instance_categories is not None: pulumi.set(__self__, "instance_categories", instance_categories) if instance_cpus is not None: @@ -79,6 +87,12 @@ def __init__(__self__, *, pulumi.set(__self__, "instance_hypervisors", instance_hypervisors) if instance_local_nvme is not None: pulumi.set(__self__, "instance_local_nvme", instance_local_nvme) + if instance_local_nvme_tip is not None: + pulumi.set(__self__, "instance_local_nvme_tip", instance_local_nvme_tip) + if instance_shapes is not None: + pulumi.set(__self__, "instance_shapes", instance_shapes) + if instance_shapes_tip is not None: + pulumi.set(__self__, "instance_shapes_tip", instance_shapes_tip) if instance_sizes is not None: pulumi.set(__self__, "instance_sizes", instance_sizes) if instance_types is not None: @@ -93,12 +107,16 @@ def __init__(__self__, *, pulumi.set(__self__, "node_class_name", node_class_name) if node_pool_name is not None: pulumi.set(__self__, "node_pool_name", node_pool_name) + if oci is not None: + pulumi.set(__self__, "oci", oci) if operating_systems is not None: pulumi.set(__self__, "operating_systems", operating_systems) if raw is not None: pulumi.set(__self__, "raw", raw) if startup_taints is not None: pulumi.set(__self__, "startup_taints", startup_taints) + if startup_taints_tip is not None: + pulumi.set(__self__, "startup_taints_tip", startup_taints_tip) if taints is not None: pulumi.set(__self__, "taints", taints) if weight is not None: @@ -180,6 +198,15 @@ def disruption(self) -> Optional[pulumi.Input['DisruptionPolicyArgsArgs']]: def disruption(self, value: Optional[pulumi.Input['DisruptionPolicyArgsArgs']]): pulumi.set(self, "disruption", value) + @_builtins.property + @pulumi.getter + def gcp(self) -> Optional[pulumi.Input['GCPNodeClassSpecArgsArgs']]: + return pulumi.get(self, "gcp") + + @gcp.setter + def gcp(self, value: Optional[pulumi.Input['GCPNodeClassSpecArgsArgs']]): + pulumi.set(self, "gcp", value) + @_builtins.property @pulumi.getter(name="instanceCategories") def instance_categories(self) -> Optional[pulumi.Input['LabelSelectorArgsArgs']]: @@ -234,6 +261,33 @@ def instance_local_nvme(self) -> Optional[pulumi.Input['LabelSelectorArgsArgs']] def instance_local_nvme(self, value: Optional[pulumi.Input['LabelSelectorArgsArgs']]): pulumi.set(self, "instance_local_nvme", value) + @_builtins.property + @pulumi.getter(name="instanceLocalNvmeTip") + def instance_local_nvme_tip(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "instance_local_nvme_tip") + + @instance_local_nvme_tip.setter + def instance_local_nvme_tip(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "instance_local_nvme_tip", value) + + @_builtins.property + @pulumi.getter(name="instanceShapes") + def instance_shapes(self) -> Optional[pulumi.Input['LabelSelectorArgsArgs']]: + return pulumi.get(self, "instance_shapes") + + @instance_shapes.setter + def instance_shapes(self, value: Optional[pulumi.Input['LabelSelectorArgsArgs']]): + pulumi.set(self, "instance_shapes", value) + + @_builtins.property + @pulumi.getter(name="instanceShapesTip") + def instance_shapes_tip(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "instance_shapes_tip") + + @instance_shapes_tip.setter + def instance_shapes_tip(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "instance_shapes_tip", value) + @_builtins.property @pulumi.getter(name="instanceSizes") def instance_sizes(self) -> Optional[pulumi.Input['LabelSelectorArgsArgs']]: @@ -297,6 +351,15 @@ def node_pool_name(self) -> Optional[pulumi.Input[_builtins.str]]: def node_pool_name(self, value: Optional[pulumi.Input[_builtins.str]]): pulumi.set(self, "node_pool_name", value) + @_builtins.property + @pulumi.getter + def oci(self) -> Optional[pulumi.Input['OCINodeClassSpecArgsArgs']]: + return pulumi.get(self, "oci") + + @oci.setter + def oci(self, value: Optional[pulumi.Input['OCINodeClassSpecArgsArgs']]): + pulumi.set(self, "oci", value) + @_builtins.property @pulumi.getter(name="operatingSystems") def operating_systems(self) -> Optional[pulumi.Input['LabelSelectorArgsArgs']]: @@ -324,6 +387,15 @@ def startup_taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TaintAr def startup_taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TaintArgsArgs']]]]): pulumi.set(self, "startup_taints", value) + @_builtins.property + @pulumi.getter(name="startupTaintsTip") + def startup_taints_tip(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "startup_taints_tip") + + @startup_taints_tip.setter + def startup_taints_tip(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "startup_taints_tip", value) + @_builtins.property @pulumi.getter def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TaintArgsArgs']]]]: @@ -374,12 +446,16 @@ def __init__(__self__, cloud_provider_id: Optional[pulumi.Input[_builtins.int]] = None, description: Optional[pulumi.Input[_builtins.str]] = None, disruption: Optional[pulumi.Input[Union['DisruptionPolicyArgsArgs', 'DisruptionPolicyArgsArgsDict']]] = None, + gcp: Optional[pulumi.Input[Union['GCPNodeClassSpecArgsArgs', 'GCPNodeClassSpecArgsArgsDict']]] = None, instance_categories: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, instance_cpus: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, instance_families: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, instance_generations: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, instance_hypervisors: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, instance_local_nvme: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, + instance_local_nvme_tip: Optional[pulumi.Input[_builtins.str]] = None, + instance_shapes: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, + instance_shapes_tip: Optional[pulumi.Input[_builtins.str]] = None, instance_sizes: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, instance_types: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, @@ -388,9 +464,11 @@ def __init__(__self__, name: Optional[pulumi.Input[_builtins.str]] = None, node_class_name: Optional[pulumi.Input[_builtins.str]] = None, node_pool_name: Optional[pulumi.Input[_builtins.str]] = None, + oci: Optional[pulumi.Input[Union['OCINodeClassSpecArgsArgs', 'OCINodeClassSpecArgsArgsDict']]] = None, operating_systems: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, raw: Optional[pulumi.Input[Sequence[pulumi.Input[Union['RawKarpenterSpecArgsArgs', 'RawKarpenterSpecArgsArgsDict']]]]] = None, startup_taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['TaintArgsArgs', 'TaintArgsArgsDict']]]]] = None, + startup_taints_tip: Optional[pulumi.Input[_builtins.str]] = None, taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['TaintArgsArgs', 'TaintArgsArgsDict']]]]] = None, weight: Optional[pulumi.Input[_builtins.int]] = None, zonal_shift: Optional[pulumi.Input[Union['ZonalShiftConfigArgsArgs', 'ZonalShiftConfigArgsArgsDict']]] = None, @@ -433,12 +511,16 @@ def _internal_init(__self__, cloud_provider_id: Optional[pulumi.Input[_builtins.int]] = None, description: Optional[pulumi.Input[_builtins.str]] = None, disruption: Optional[pulumi.Input[Union['DisruptionPolicyArgsArgs', 'DisruptionPolicyArgsArgsDict']]] = None, + gcp: Optional[pulumi.Input[Union['GCPNodeClassSpecArgsArgs', 'GCPNodeClassSpecArgsArgsDict']]] = None, instance_categories: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, instance_cpus: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, instance_families: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, instance_generations: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, instance_hypervisors: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, instance_local_nvme: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, + instance_local_nvme_tip: Optional[pulumi.Input[_builtins.str]] = None, + instance_shapes: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, + instance_shapes_tip: Optional[pulumi.Input[_builtins.str]] = None, instance_sizes: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, instance_types: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, @@ -447,9 +529,11 @@ def _internal_init(__self__, name: Optional[pulumi.Input[_builtins.str]] = None, node_class_name: Optional[pulumi.Input[_builtins.str]] = None, node_pool_name: Optional[pulumi.Input[_builtins.str]] = None, + oci: Optional[pulumi.Input[Union['OCINodeClassSpecArgsArgs', 'OCINodeClassSpecArgsArgsDict']]] = None, operating_systems: Optional[pulumi.Input[Union['LabelSelectorArgsArgs', 'LabelSelectorArgsArgsDict']]] = None, raw: Optional[pulumi.Input[Sequence[pulumi.Input[Union['RawKarpenterSpecArgsArgs', 'RawKarpenterSpecArgsArgsDict']]]]] = None, startup_taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['TaintArgsArgs', 'TaintArgsArgsDict']]]]] = None, + startup_taints_tip: Optional[pulumi.Input[_builtins.str]] = None, taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['TaintArgsArgs', 'TaintArgsArgsDict']]]]] = None, weight: Optional[pulumi.Input[_builtins.int]] = None, zonal_shift: Optional[pulumi.Input[Union['ZonalShiftConfigArgsArgs', 'ZonalShiftConfigArgsArgsDict']]] = None, @@ -470,12 +554,16 @@ def _internal_init(__self__, __props__.__dict__["cloud_provider_id"] = cloud_provider_id __props__.__dict__["description"] = description __props__.__dict__["disruption"] = disruption + __props__.__dict__["gcp"] = gcp __props__.__dict__["instance_categories"] = instance_categories __props__.__dict__["instance_cpus"] = instance_cpus __props__.__dict__["instance_families"] = instance_families __props__.__dict__["instance_generations"] = instance_generations __props__.__dict__["instance_hypervisors"] = instance_hypervisors __props__.__dict__["instance_local_nvme"] = instance_local_nvme + __props__.__dict__["instance_local_nvme_tip"] = instance_local_nvme_tip + __props__.__dict__["instance_shapes"] = instance_shapes + __props__.__dict__["instance_shapes_tip"] = instance_shapes_tip __props__.__dict__["instance_sizes"] = instance_sizes __props__.__dict__["instance_types"] = instance_types __props__.__dict__["labels"] = labels @@ -486,9 +574,11 @@ def _internal_init(__self__, __props__.__dict__["name"] = name __props__.__dict__["node_class_name"] = node_class_name __props__.__dict__["node_pool_name"] = node_pool_name + __props__.__dict__["oci"] = oci __props__.__dict__["operating_systems"] = operating_systems __props__.__dict__["raw"] = raw __props__.__dict__["startup_taints"] = startup_taints + __props__.__dict__["startup_taints_tip"] = startup_taints_tip __props__.__dict__["taints"] = taints __props__.__dict__["weight"] = weight __props__.__dict__["zonal_shift"] = zonal_shift @@ -522,12 +612,16 @@ def get(resource_name: str, __props__.__dict__["cloud_provider_id"] = None __props__.__dict__["description"] = None __props__.__dict__["disruption"] = None + __props__.__dict__["gcp"] = None __props__.__dict__["instance_categories"] = None __props__.__dict__["instance_cpus"] = None __props__.__dict__["instance_families"] = None __props__.__dict__["instance_generations"] = None __props__.__dict__["instance_hypervisors"] = None __props__.__dict__["instance_local_nvme"] = None + __props__.__dict__["instance_local_nvme_tip"] = None + __props__.__dict__["instance_shapes"] = None + __props__.__dict__["instance_shapes_tip"] = None __props__.__dict__["instance_sizes"] = None __props__.__dict__["instance_types"] = None __props__.__dict__["labels"] = None @@ -536,9 +630,11 @@ def get(resource_name: str, __props__.__dict__["name"] = None __props__.__dict__["node_class_name"] = None __props__.__dict__["node_pool_name"] = None + __props__.__dict__["oci"] = None __props__.__dict__["operating_systems"] = None __props__.__dict__["raw"] = None __props__.__dict__["startup_taints"] = None + __props__.__dict__["startup_taints_tip"] = None __props__.__dict__["taints"] = None __props__.__dict__["weight"] = None __props__.__dict__["zonal_shift"] = None @@ -598,6 +694,14 @@ def disruption(self) -> pulumi.Output[Optional['outputs.DisruptionPolicyArgs']]: """ return pulumi.get(self, "disruption") + @_builtins.property + @pulumi.getter + def gcp(self) -> pulumi.Output[Optional['outputs.GCPNodeClassSpecArgs']]: + """ + GCP-specific GCENodeClass configuration (service account, images, disks, etc.). + """ + return pulumi.get(self, "gcp") + @_builtins.property @pulumi.getter(name="instanceCategories") def instance_categories(self) -> pulumi.Output[Optional['outputs.LabelSelectorArgs']]: @@ -643,6 +747,30 @@ def instance_hypervisors(self) -> pulumi.Output[Optional['outputs.LabelSelectorA def instance_local_nvme(self) -> pulumi.Output[Optional['outputs.LabelSelectorArgs']]: return pulumi.get(self, "instance_local_nvme") + @_builtins.property + @pulumi.getter(name="instanceLocalNvmeTip") + def instance_local_nvme_tip(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + UI tooltip text shown alongside the instanceLocalNvme selector. + """ + return pulumi.get(self, "instance_local_nvme_tip") + + @_builtins.property + @pulumi.getter(name="instanceShapes") + def instance_shapes(self) -> pulumi.Output[Optional['outputs.LabelSelectorArgs']]: + """ + GCP-only: filter by standard/highcpu/highmem custom shape token. Example: {in: ["standard", "highmem"]}. + """ + return pulumi.get(self, "instance_shapes") + + @_builtins.property + @pulumi.getter(name="instanceShapesTip") + def instance_shapes_tip(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + UI tooltip text shown alongside the instanceShapes selector. + """ + return pulumi.get(self, "instance_shapes_tip") + @_builtins.property @pulumi.getter(name="instanceSizes") def instance_sizes(self) -> pulumi.Output[Optional['outputs.LabelSelectorArgs']]: @@ -704,6 +832,14 @@ def node_pool_name(self) -> pulumi.Output[Optional[_builtins.str]]: """ return pulumi.get(self, "node_pool_name") + @_builtins.property + @pulumi.getter + def oci(self) -> pulumi.Output[Optional['outputs.OCINodeClassSpecArgs']]: + """ + OCI-specific NodeClass configuration (VCN, subnets, images, block volumes, etc.). + """ + return pulumi.get(self, "oci") + @_builtins.property @pulumi.getter(name="operatingSystems") def operating_systems(self) -> pulumi.Output[Optional['outputs.LabelSelectorArgs']]: @@ -725,6 +861,14 @@ def raw(self) -> pulumi.Output[Optional[Sequence['outputs.RawKarpenterSpecArgs'] def startup_taints(self) -> pulumi.Output[Optional[Sequence['outputs.TaintArgs']]]: return pulumi.get(self, "startup_taints") + @_builtins.property + @pulumi.getter(name="startupTaintsTip") + def startup_taints_tip(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + UI tooltip text shown alongside startupTaints. + """ + return pulumi.get(self, "startup_taints_tip") + @_builtins.property @pulumi.getter def taints(self) -> pulumi.Output[Optional[Sequence['outputs.TaintArgs']]]: diff --git a/sdk/python/pulumi_devzero/resources/outputs.py b/sdk/python/pulumi_devzero/resources/outputs.py index 1841343..cba3600 100644 --- a/sdk/python/pulumi_devzero/resources/outputs.py +++ b/sdk/python/pulumi_devzero/resources/outputs.py @@ -27,6 +27,9 @@ 'DisruptionBudgetArgs', 'DisruptionPolicyArgs', 'EmergencyResponseConfigArgs', + 'GCPDiskArgs', + 'GCPImageSelectorTermArgs', + 'GCPNodeClassSpecArgs', 'HPABehaviorArgs', 'HPAFallbackArgs', 'HPAMetricTriggerArgs', @@ -34,11 +37,24 @@ 'HPAScalingPolicyArgs', 'HPAScalingRulesArgs', 'HorizontalScalingArgs', + 'JvmHeapRuleConfigArgs', + 'KedaAdvancedArgs', + 'KedaAuthenticationRefArgs', + 'KedaFallbackArgs', + 'KedaScaledObjectArgs', + 'KedaTriggerArgs', 'KubeletConfigurationArgs', 'LabelSelectorArgs', 'LabelSelectorRequirementArgs', 'MetadataOptionsArgs', 'NamePatternArgs', + 'OCIBootConfigArgs', + 'OCIImageSelectorTermArgs', + 'OCILaunchOptionsArgs', + 'OCINodeClassSpecArgs', + 'OCISecurityGroupSelectorTermArgs', + 'OCISubnetSelectorTermArgs', + 'OCIVolumeAttributesArgs', 'RawKarpenterSpecArgs', 'ResourceLimitsArgs', 'ResourceRuleConfigArgs', @@ -1291,6 +1307,251 @@ def oom_memory_multiplier(self) -> Optional[_builtins.float]: return pulumi.get(self, "oom_memory_multiplier") +@pulumi.output_type +class GCPDiskArgs(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "secondaryBootImage": + suggest = "secondary_boot_image" + elif key == "secondaryBootMode": + suggest = "secondary_boot_mode" + elif key == "sizeGib": + suggest = "size_gib" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in GCPDiskArgs. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + GCPDiskArgs.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + GCPDiskArgs.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + boot: Optional[_builtins.bool] = None, + category: Optional[_builtins.str] = None, + secondary_boot_image: Optional[_builtins.str] = None, + secondary_boot_mode: Optional[_builtins.str] = None, + size_gib: Optional[_builtins.int] = None): + """ + :param _builtins.bool boot: Whether this disk is the boot disk. Example: true. + :param _builtins.str category: GCP disk type. Example: 'pd-ssd'. + :param _builtins.str secondary_boot_image: Secondary boot image used for container-image fast boot. Example: 'projects/my-project/global/images/my-cache-image'. + :param _builtins.str secondary_boot_mode: Secondary boot mode. Example: 'CONTAINER_IMAGE_CACHE'. + :param _builtins.int size_gib: Disk size in GiB. Example: 100. + """ + if boot is not None: + pulumi.set(__self__, "boot", boot) + if category is not None: + pulumi.set(__self__, "category", category) + if secondary_boot_image is not None: + pulumi.set(__self__, "secondary_boot_image", secondary_boot_image) + if secondary_boot_mode is not None: + pulumi.set(__self__, "secondary_boot_mode", secondary_boot_mode) + if size_gib is not None: + pulumi.set(__self__, "size_gib", size_gib) + + @_builtins.property + @pulumi.getter + def boot(self) -> Optional[_builtins.bool]: + """ + Whether this disk is the boot disk. Example: true. + """ + return pulumi.get(self, "boot") + + @_builtins.property + @pulumi.getter + def category(self) -> Optional[_builtins.str]: + """ + GCP disk type. Example: 'pd-ssd'. + """ + return pulumi.get(self, "category") + + @_builtins.property + @pulumi.getter(name="secondaryBootImage") + def secondary_boot_image(self) -> Optional[_builtins.str]: + """ + Secondary boot image used for container-image fast boot. Example: 'projects/my-project/global/images/my-cache-image'. + """ + return pulumi.get(self, "secondary_boot_image") + + @_builtins.property + @pulumi.getter(name="secondaryBootMode") + def secondary_boot_mode(self) -> Optional[_builtins.str]: + """ + Secondary boot mode. Example: 'CONTAINER_IMAGE_CACHE'. + """ + return pulumi.get(self, "secondary_boot_mode") + + @_builtins.property + @pulumi.getter(name="sizeGib") + def size_gib(self) -> Optional[_builtins.int]: + """ + Disk size in GiB. Example: 100. + """ + return pulumi.get(self, "size_gib") + + +@pulumi.output_type +class GCPImageSelectorTermArgs(dict): + def __init__(__self__, *, + alias: Optional[_builtins.str] = None, + id: Optional[_builtins.str] = None): + """ + :param _builtins.str alias: Well-known alias for the GCP node image family. Example: 'cos@latest'. + :param _builtins.str id: Explicit GCP image ID. Example: 'projects/cos-cloud/global/images/cos-105-17412-156-59'. + """ + if alias is not None: + pulumi.set(__self__, "alias", alias) + if id is not None: + pulumi.set(__self__, "id", id) + + @_builtins.property + @pulumi.getter + def alias(self) -> Optional[_builtins.str]: + """ + Well-known alias for the GCP node image family. Example: 'cos@latest'. + """ + return pulumi.get(self, "alias") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + """ + Explicit GCP image ID. Example: 'projects/cos-cloud/global/images/cos-105-17412-156-59'. + """ + return pulumi.get(self, "id") + + +@pulumi.output_type +class GCPNodeClassSpecArgs(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "imageFamily": + suggest = "image_family" + elif key == "imageSelectorTerms": + suggest = "image_selector_terms" + elif key == "networkTags": + suggest = "network_tags" + elif key == "serviceAccount": + suggest = "service_account" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in GCPNodeClassSpecArgs. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + GCPNodeClassSpecArgs.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + GCPNodeClassSpecArgs.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + disks: Optional[Sequence['outputs.GCPDiskArgs']] = None, + image_family: Optional[_builtins.str] = None, + image_selector_terms: Optional[Sequence['outputs.GCPImageSelectorTermArgs']] = None, + kubelet: Optional['outputs.KubeletConfigurationArgs'] = None, + labels: Optional[Mapping[str, _builtins.str]] = None, + metadata: Optional[Mapping[str, _builtins.str]] = None, + network_tags: Optional[Sequence[_builtins.str]] = None, + service_account: Optional[_builtins.str] = None): + """ + :param Sequence['GCPDiskArgs'] disks: Disks attached to provisioned nodes. Example: [{sizeGib: 100, category: "pd-ssd", boot: true}]. + :param _builtins.str image_family: GCP node image family shorthand used when no imageSelectorTerms are specified. Example: 'cos'. + :param Sequence['GCPImageSelectorTermArgs'] image_selector_terms: Selectors for the node images used to launch nodes. Example: [{alias: "cos@latest"}]. + :param 'KubeletConfigurationArgs' kubelet: Kubelet configuration overrides applied to all nodes in this class. + :param Mapping[str, _builtins.str] labels: GCP labels applied to all resources created by this node class. Example: {"environment": "production"}. + :param Mapping[str, _builtins.str] metadata: GCE instance metadata applied to provisioned nodes. Example: {"disable-legacy-endpoints": "true"}. + :param Sequence[_builtins.str] network_tags: GCP network tags applied to provisioned nodes for firewall targeting. Example: ["karpenter-node"]. + :param _builtins.str service_account: GCP service account email attached to provisioned nodes. Example: 'karpenter@my-project.iam.gserviceaccount.com'. + """ + if disks is not None: + pulumi.set(__self__, "disks", disks) + if image_family is not None: + pulumi.set(__self__, "image_family", image_family) + if image_selector_terms is not None: + pulumi.set(__self__, "image_selector_terms", image_selector_terms) + if kubelet is not None: + pulumi.set(__self__, "kubelet", kubelet) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if metadata is not None: + pulumi.set(__self__, "metadata", metadata) + if network_tags is not None: + pulumi.set(__self__, "network_tags", network_tags) + if service_account is not None: + pulumi.set(__self__, "service_account", service_account) + + @_builtins.property + @pulumi.getter + def disks(self) -> Optional[Sequence['outputs.GCPDiskArgs']]: + """ + Disks attached to provisioned nodes. Example: [{sizeGib: 100, category: "pd-ssd", boot: true}]. + """ + return pulumi.get(self, "disks") + + @_builtins.property + @pulumi.getter(name="imageFamily") + def image_family(self) -> Optional[_builtins.str]: + """ + GCP node image family shorthand used when no imageSelectorTerms are specified. Example: 'cos'. + """ + return pulumi.get(self, "image_family") + + @_builtins.property + @pulumi.getter(name="imageSelectorTerms") + def image_selector_terms(self) -> Optional[Sequence['outputs.GCPImageSelectorTermArgs']]: + """ + Selectors for the node images used to launch nodes. Example: [{alias: "cos@latest"}]. + """ + return pulumi.get(self, "image_selector_terms") + + @_builtins.property + @pulumi.getter + def kubelet(self) -> Optional['outputs.KubeletConfigurationArgs']: + """ + Kubelet configuration overrides applied to all nodes in this class. + """ + return pulumi.get(self, "kubelet") + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[Mapping[str, _builtins.str]]: + """ + GCP labels applied to all resources created by this node class. Example: {"environment": "production"}. + """ + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def metadata(self) -> Optional[Mapping[str, _builtins.str]]: + """ + GCE instance metadata applied to provisioned nodes. Example: {"disable-legacy-endpoints": "true"}. + """ + return pulumi.get(self, "metadata") + + @_builtins.property + @pulumi.getter(name="networkTags") + def network_tags(self) -> Optional[Sequence[_builtins.str]]: + """ + GCP network tags applied to provisioned nodes for firewall targeting. Example: ["karpenter-node"]. + """ + return pulumi.get(self, "network_tags") + + @_builtins.property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> Optional[_builtins.str]: + """ + GCP service account email attached to provisioned nodes. Example: 'karpenter@my-project.iam.gserviceaccount.com'. + """ + return pulumi.get(self, "service_account") + + @pulumi.output_type class HPABehaviorArgs(dict): @staticmethod @@ -1939,395 +2200,1434 @@ def target_utilization(self) -> Optional[_builtins.float]: @pulumi.output_type -class KubeletConfigurationArgs(dict): +class JvmHeapRuleConfigArgs(dict): @staticmethod def __key_warning(key: str): suggest = None - if key == "clusterDns": - suggest = "cluster_dns" - elif key == "cpuCfsQuota": - suggest = "cpu_cfs_quota" - elif key == "evictionHard": - suggest = "eviction_hard" - elif key == "evictionMaxPodGracePeriod": - suggest = "eviction_max_pod_grace_period" - elif key == "evictionSoft": - suggest = "eviction_soft" - elif key == "evictionSoftGracePeriod": - suggest = "eviction_soft_grace_period" - elif key == "imageGcHighThresholdPercent": - suggest = "image_gc_high_threshold_percent" - elif key == "imageGcLowThresholdPercent": - suggest = "image_gc_low_threshold_percent" - elif key == "kubeReserved": - suggest = "kube_reserved" - elif key == "maxPods": - suggest = "max_pods" - elif key == "podsPerCore": - suggest = "pods_per_core" - elif key == "systemReserved": - suggest = "system_reserved" + if key == "headroomMultiplier": + suggest = "headroom_multiplier" + elif key == "maxHeapBytes": + suggest = "max_heap_bytes" + elif key == "minHeapBytes": + suggest = "min_heap_bytes" + elif key == "nonHeapOverheadBytes": + suggest = "non_heap_overhead_bytes" + elif key == "nonHeapOverheadPercent": + suggest = "non_heap_overhead_percent" + elif key == "preferContainerSupport": + suggest = "prefer_container_support" + elif key == "targetPercentile": + suggest = "target_percentile" if suggest: - pulumi.log.warn(f"Key '{key}' not found in KubeletConfigurationArgs. Access the value via the '{suggest}' property getter instead.") + pulumi.log.warn(f"Key '{key}' not found in JvmHeapRuleConfigArgs. Access the value via the '{suggest}' property getter instead.") def __getitem__(self, key: str) -> Any: - KubeletConfigurationArgs.__key_warning(key) + JvmHeapRuleConfigArgs.__key_warning(key) return super().__getitem__(key) def get(self, key: str, default = None) -> Any: - KubeletConfigurationArgs.__key_warning(key) + JvmHeapRuleConfigArgs.__key_warning(key) return super().get(key, default) def __init__(__self__, *, - cluster_dns: Optional[Sequence[_builtins.str]] = None, - cpu_cfs_quota: Optional[_builtins.bool] = None, - eviction_hard: Optional[Mapping[str, _builtins.str]] = None, - eviction_max_pod_grace_period: Optional[_builtins.int] = None, - eviction_soft: Optional[Mapping[str, _builtins.str]] = None, - eviction_soft_grace_period: Optional[Mapping[str, _builtins.str]] = None, - image_gc_high_threshold_percent: Optional[_builtins.int] = None, - image_gc_low_threshold_percent: Optional[_builtins.int] = None, - kube_reserved: Optional[Mapping[str, _builtins.str]] = None, - max_pods: Optional[_builtins.int] = None, - pods_per_core: Optional[_builtins.int] = None, - system_reserved: Optional[Mapping[str, _builtins.str]] = None): + enabled: Optional[_builtins.bool] = None, + headroom_multiplier: Optional[_builtins.float] = None, + max_heap_bytes: Optional[_builtins.int] = None, + min_heap_bytes: Optional[_builtins.int] = None, + non_heap_overhead_bytes: Optional[_builtins.int] = None, + non_heap_overhead_percent: Optional[_builtins.float] = None, + prefer_container_support: Optional[_builtins.bool] = None, + target_percentile: Optional[_builtins.float] = None): """ - :param Sequence[_builtins.str] cluster_dns: DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. - :param _builtins.bool cpu_cfs_quota: Whether to enforce CPU CFS quota limits for containers. Example: true. - :param Mapping[str, _builtins.str] eviction_hard: Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. - :param _builtins.int eviction_max_pod_grace_period: Maximum pod termination grace period (seconds) during eviction. Example: 90. - :param Mapping[str, _builtins.str] eviction_soft: Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. - :param Mapping[str, _builtins.str] eviction_soft_grace_period: Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. - :param _builtins.int image_gc_high_threshold_percent: Disk usage % that triggers image garbage collection. Example: 85. - :param _builtins.int image_gc_low_threshold_percent: Disk usage % at which image GC stops freeing space. Example: 70. - :param Mapping[str, _builtins.str] kube_reserved: Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. - :param _builtins.int max_pods: Maximum number of pods allowed per node. Example: 110. - :param _builtins.int pods_per_core: Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. - :param Mapping[str, _builtins.str] system_reserved: Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. + :param _builtins.bool enabled: Enable JVM heap sizing overrides. Example: true. + :param _builtins.float headroom_multiplier: Multiplier applied above the target usage to derive the heap size. Example: 1.3. + :param _builtins.int max_heap_bytes: Maximum JVM heap size in bytes. Example: 2147483648. + :param _builtins.int min_heap_bytes: Minimum JVM heap size in bytes. Example: 134217728. + :param _builtins.int non_heap_overhead_bytes: Non-heap memory overhead in bytes. Takes precedence over nonHeapOverheadPercent when set. Example: 268435456. + :param _builtins.float non_heap_overhead_percent: Non-heap memory overhead as a percentage of container memory (0-1). Example: 0.2. + :param _builtins.bool prefer_container_support: Prefer the JVM's native container-aware heap sizing (-XX:+UseContainerSupport) over explicit -Xmx/-Xms flags. Example: false. + :param _builtins.float target_percentile: Percentile of usage data used as the heap sizing target (0-1). Example: 0.95. """ - if cluster_dns is not None: - pulumi.set(__self__, "cluster_dns", cluster_dns) - if cpu_cfs_quota is not None: - pulumi.set(__self__, "cpu_cfs_quota", cpu_cfs_quota) - if eviction_hard is not None: - pulumi.set(__self__, "eviction_hard", eviction_hard) - if eviction_max_pod_grace_period is not None: - pulumi.set(__self__, "eviction_max_pod_grace_period", eviction_max_pod_grace_period) - if eviction_soft is not None: - pulumi.set(__self__, "eviction_soft", eviction_soft) - if eviction_soft_grace_period is not None: - pulumi.set(__self__, "eviction_soft_grace_period", eviction_soft_grace_period) - if image_gc_high_threshold_percent is not None: - pulumi.set(__self__, "image_gc_high_threshold_percent", image_gc_high_threshold_percent) - if image_gc_low_threshold_percent is not None: - pulumi.set(__self__, "image_gc_low_threshold_percent", image_gc_low_threshold_percent) - if kube_reserved is not None: - pulumi.set(__self__, "kube_reserved", kube_reserved) - if max_pods is not None: - pulumi.set(__self__, "max_pods", max_pods) - if pods_per_core is not None: - pulumi.set(__self__, "pods_per_core", pods_per_core) - if system_reserved is not None: - pulumi.set(__self__, "system_reserved", system_reserved) + if enabled is not None: + pulumi.set(__self__, "enabled", enabled) + if headroom_multiplier is not None: + pulumi.set(__self__, "headroom_multiplier", headroom_multiplier) + if max_heap_bytes is not None: + pulumi.set(__self__, "max_heap_bytes", max_heap_bytes) + if min_heap_bytes is not None: + pulumi.set(__self__, "min_heap_bytes", min_heap_bytes) + if non_heap_overhead_bytes is not None: + pulumi.set(__self__, "non_heap_overhead_bytes", non_heap_overhead_bytes) + if non_heap_overhead_percent is not None: + pulumi.set(__self__, "non_heap_overhead_percent", non_heap_overhead_percent) + if prefer_container_support is not None: + pulumi.set(__self__, "prefer_container_support", prefer_container_support) + if target_percentile is not None: + pulumi.set(__self__, "target_percentile", target_percentile) @_builtins.property - @pulumi.getter(name="clusterDns") - def cluster_dns(self) -> Optional[Sequence[_builtins.str]]: + @pulumi.getter + def enabled(self) -> Optional[_builtins.bool]: """ - DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. + Enable JVM heap sizing overrides. Example: true. """ - return pulumi.get(self, "cluster_dns") + return pulumi.get(self, "enabled") @_builtins.property - @pulumi.getter(name="cpuCfsQuota") - def cpu_cfs_quota(self) -> Optional[_builtins.bool]: + @pulumi.getter(name="headroomMultiplier") + def headroom_multiplier(self) -> Optional[_builtins.float]: """ - Whether to enforce CPU CFS quota limits for containers. Example: true. + Multiplier applied above the target usage to derive the heap size. Example: 1.3. """ - return pulumi.get(self, "cpu_cfs_quota") + return pulumi.get(self, "headroom_multiplier") @_builtins.property - @pulumi.getter(name="evictionHard") - def eviction_hard(self) -> Optional[Mapping[str, _builtins.str]]: + @pulumi.getter(name="maxHeapBytes") + def max_heap_bytes(self) -> Optional[_builtins.int]: """ - Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. + Maximum JVM heap size in bytes. Example: 2147483648. """ - return pulumi.get(self, "eviction_hard") + return pulumi.get(self, "max_heap_bytes") @_builtins.property - @pulumi.getter(name="evictionMaxPodGracePeriod") - def eviction_max_pod_grace_period(self) -> Optional[_builtins.int]: + @pulumi.getter(name="minHeapBytes") + def min_heap_bytes(self) -> Optional[_builtins.int]: """ - Maximum pod termination grace period (seconds) during eviction. Example: 90. + Minimum JVM heap size in bytes. Example: 134217728. """ - return pulumi.get(self, "eviction_max_pod_grace_period") + return pulumi.get(self, "min_heap_bytes") @_builtins.property - @pulumi.getter(name="evictionSoft") - def eviction_soft(self) -> Optional[Mapping[str, _builtins.str]]: + @pulumi.getter(name="nonHeapOverheadBytes") + def non_heap_overhead_bytes(self) -> Optional[_builtins.int]: """ - Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. + Non-heap memory overhead in bytes. Takes precedence over nonHeapOverheadPercent when set. Example: 268435456. """ - return pulumi.get(self, "eviction_soft") + return pulumi.get(self, "non_heap_overhead_bytes") @_builtins.property - @pulumi.getter(name="evictionSoftGracePeriod") - def eviction_soft_grace_period(self) -> Optional[Mapping[str, _builtins.str]]: + @pulumi.getter(name="nonHeapOverheadPercent") + def non_heap_overhead_percent(self) -> Optional[_builtins.float]: """ - Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. + Non-heap memory overhead as a percentage of container memory (0-1). Example: 0.2. """ - return pulumi.get(self, "eviction_soft_grace_period") + return pulumi.get(self, "non_heap_overhead_percent") @_builtins.property - @pulumi.getter(name="imageGcHighThresholdPercent") - def image_gc_high_threshold_percent(self) -> Optional[_builtins.int]: + @pulumi.getter(name="preferContainerSupport") + def prefer_container_support(self) -> Optional[_builtins.bool]: """ - Disk usage % that triggers image garbage collection. Example: 85. + Prefer the JVM's native container-aware heap sizing (-XX:+UseContainerSupport) over explicit -Xmx/-Xms flags. Example: false. """ - return pulumi.get(self, "image_gc_high_threshold_percent") + return pulumi.get(self, "prefer_container_support") @_builtins.property - @pulumi.getter(name="imageGcLowThresholdPercent") - def image_gc_low_threshold_percent(self) -> Optional[_builtins.int]: + @pulumi.getter(name="targetPercentile") + def target_percentile(self) -> Optional[_builtins.float]: """ - Disk usage % at which image GC stops freeing space. Example: 70. + Percentile of usage data used as the heap sizing target (0-1). Example: 0.95. """ - return pulumi.get(self, "image_gc_low_threshold_percent") + return pulumi.get(self, "target_percentile") + + +@pulumi.output_type +class KedaAdvancedArgs(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "advancedBehaviorJson": + suggest = "advanced_behavior_json" + elif key == "restoreToOriginalReplicaCount": + suggest = "restore_to_original_replica_count" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in KedaAdvancedArgs. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + KedaAdvancedArgs.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + KedaAdvancedArgs.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + advanced_behavior_json: Optional[_builtins.str] = None, + restore_to_original_replica_count: Optional[_builtins.bool] = None): + """ + :param _builtins.str advanced_behavior_json: Kubernetes HorizontalPodAutoscalerBehavior encoded as a JSON string, applied to the generated HPA. Example: '{"scaleDown":{"stabilizationWindowSeconds":300}}'. + :param _builtins.bool restore_to_original_replica_count: Restore the original replica count when the ScaledObject is deleted. Example: false. + """ + if advanced_behavior_json is not None: + pulumi.set(__self__, "advanced_behavior_json", advanced_behavior_json) + if restore_to_original_replica_count is not None: + pulumi.set(__self__, "restore_to_original_replica_count", restore_to_original_replica_count) @_builtins.property - @pulumi.getter(name="kubeReserved") - def kube_reserved(self) -> Optional[Mapping[str, _builtins.str]]: + @pulumi.getter(name="advancedBehaviorJson") + def advanced_behavior_json(self) -> Optional[_builtins.str]: """ - Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. + Kubernetes HorizontalPodAutoscalerBehavior encoded as a JSON string, applied to the generated HPA. Example: '{"scaleDown":{"stabilizationWindowSeconds":300}}'. """ - return pulumi.get(self, "kube_reserved") + return pulumi.get(self, "advanced_behavior_json") @_builtins.property - @pulumi.getter(name="maxPods") - def max_pods(self) -> Optional[_builtins.int]: + @pulumi.getter(name="restoreToOriginalReplicaCount") + def restore_to_original_replica_count(self) -> Optional[_builtins.bool]: """ - Maximum number of pods allowed per node. Example: 110. + Restore the original replica count when the ScaledObject is deleted. Example: false. """ - return pulumi.get(self, "max_pods") + return pulumi.get(self, "restore_to_original_replica_count") + + +@pulumi.output_type +class KedaAuthenticationRefArgs(dict): + def __init__(__self__, *, + name: _builtins.str, + kind: Optional[_builtins.str] = None): + """ + :param _builtins.str name: Name of the referenced TriggerAuthentication/ClusterTriggerAuthentication resource. Example: 'prometheus-auth'. + :param _builtins.str kind: Kind of the referenced resource. One of: 'TriggerAuthentication', 'ClusterTriggerAuthentication'. Example: 'TriggerAuthentication'. + """ + pulumi.set(__self__, "name", name) + if kind is not None: + pulumi.set(__self__, "kind", kind) @_builtins.property - @pulumi.getter(name="podsPerCore") - def pods_per_core(self) -> Optional[_builtins.int]: + @pulumi.getter + def name(self) -> _builtins.str: """ - Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. + Name of the referenced TriggerAuthentication/ClusterTriggerAuthentication resource. Example: 'prometheus-auth'. """ - return pulumi.get(self, "pods_per_core") + return pulumi.get(self, "name") @_builtins.property - @pulumi.getter(name="systemReserved") - def system_reserved(self) -> Optional[Mapping[str, _builtins.str]]: + @pulumi.getter + def kind(self) -> Optional[_builtins.str]: """ - Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. + Kind of the referenced resource. One of: 'TriggerAuthentication', 'ClusterTriggerAuthentication'. Example: 'TriggerAuthentication'. """ - return pulumi.get(self, "system_reserved") + return pulumi.get(self, "kind") @pulumi.output_type -class LabelSelectorArgs(dict): +class KedaFallbackArgs(dict): @staticmethod def __key_warning(key: str): suggest = None - if key == "matchExpressions": - suggest = "match_expressions" - elif key == "matchLabels": - suggest = "match_labels" + if key == "failureThreshold": + suggest = "failure_threshold" if suggest: - pulumi.log.warn(f"Key '{key}' not found in LabelSelectorArgs. Access the value via the '{suggest}' property getter instead.") + pulumi.log.warn(f"Key '{key}' not found in KedaFallbackArgs. Access the value via the '{suggest}' property getter instead.") def __getitem__(self, key: str) -> Any: - LabelSelectorArgs.__key_warning(key) + KedaFallbackArgs.__key_warning(key) return super().__getitem__(key) def get(self, key: str, default = None) -> Any: - LabelSelectorArgs.__key_warning(key) + KedaFallbackArgs.__key_warning(key) return super().get(key, default) def __init__(__self__, *, - match_expressions: Optional[Sequence['outputs.LabelSelectorRequirementArgs']] = None, - match_labels: Optional[Mapping[str, _builtins.str]] = None): + failure_threshold: _builtins.int, + replicas: _builtins.int, + behavior: Optional[_builtins.str] = None): """ - :param Sequence['LabelSelectorRequirementArgs'] match_expressions: List of label selector requirements joined by AND. - :param Mapping[str, _builtins.str] match_labels: Map of label key-value pairs that must all match exactly. + :param _builtins.int failure_threshold: Number of consecutive metric failures before activating fallback. Example: 3. + :param _builtins.int replicas: Number of replicas to fall back to when metrics are unavailable. Example: 2. + :param _builtins.str behavior: Fallback strategy. Example: 'static'. """ - if match_expressions is not None: - pulumi.set(__self__, "match_expressions", match_expressions) - if match_labels is not None: - pulumi.set(__self__, "match_labels", match_labels) + pulumi.set(__self__, "failure_threshold", failure_threshold) + pulumi.set(__self__, "replicas", replicas) + if behavior is not None: + pulumi.set(__self__, "behavior", behavior) @_builtins.property - @pulumi.getter(name="matchExpressions") - def match_expressions(self) -> Optional[Sequence['outputs.LabelSelectorRequirementArgs']]: + @pulumi.getter(name="failureThreshold") + def failure_threshold(self) -> _builtins.int: """ - List of label selector requirements joined by AND. + Number of consecutive metric failures before activating fallback. Example: 3. """ - return pulumi.get(self, "match_expressions") + return pulumi.get(self, "failure_threshold") @_builtins.property - @pulumi.getter(name="matchLabels") - def match_labels(self) -> Optional[Mapping[str, _builtins.str]]: + @pulumi.getter + def replicas(self) -> _builtins.int: """ - Map of label key-value pairs that must all match exactly. + Number of replicas to fall back to when metrics are unavailable. Example: 2. """ - return pulumi.get(self, "match_labels") + return pulumi.get(self, "replicas") + + @_builtins.property + @pulumi.getter + def behavior(self) -> Optional[_builtins.str]: + """ + Fallback strategy. Example: 'static'. + """ + return pulumi.get(self, "behavior") @pulumi.output_type -class LabelSelectorRequirementArgs(dict): +class KedaScaledObjectArgs(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "cooldownPeriod": + suggest = "cooldown_period" + elif key == "idleReplicaCount": + suggest = "idle_replica_count" + elif key == "initialCooldownPeriod": + suggest = "initial_cooldown_period" + elif key == "maxReplicaCount": + suggest = "max_replica_count" + elif key == "minReplicaCount": + suggest = "min_replica_count" + elif key == "pollingInterval": + suggest = "polling_interval" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in KedaScaledObjectArgs. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + KedaScaledObjectArgs.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + KedaScaledObjectArgs.__key_warning(key) + return super().get(key, default) + def __init__(__self__, *, - key: Optional[_builtins.str] = None, - operator: Optional[_builtins.str] = None, - values: Optional[Sequence[_builtins.str]] = None): + advanced: Optional['outputs.KedaAdvancedArgs'] = None, + cooldown_period: Optional[_builtins.int] = None, + fallback: Optional['outputs.KedaFallbackArgs'] = None, + idle_replica_count: Optional[_builtins.int] = None, + initial_cooldown_period: Optional[_builtins.int] = None, + max_replica_count: Optional[_builtins.int] = None, + min_replica_count: Optional[_builtins.int] = None, + polling_interval: Optional[_builtins.int] = None, + triggers: Optional[Sequence['outputs.KedaTriggerArgs']] = None): + """ + :param 'KedaAdvancedArgs' advanced: Advanced ScaledObject behavior configuration. + :param _builtins.int cooldown_period: Seconds to wait after the last trigger reports active=false before scaling to minReplicaCount. Example: 300. + :param 'KedaFallbackArgs' fallback: Replica fallback configuration when KEDA metrics are unavailable. + :param _builtins.int idle_replica_count: Replica count to scale to when idle. Must be less than minReplicaCount. Example: 0. + :param _builtins.int initial_cooldown_period: Cooldown period applied only during the initial scaling of the ScaledObject. Example: 0. + :param _builtins.int max_replica_count: Maximum number of replicas. Example: 10. + :param _builtins.int min_replica_count: Minimum number of replicas. Example: 0. + :param _builtins.int polling_interval: Seconds between checks of trigger metrics. Example: 30. + :param Sequence['KedaTriggerArgs'] triggers: KEDA scaler triggers driving this ScaledObject. + """ + if advanced is not None: + pulumi.set(__self__, "advanced", advanced) + if cooldown_period is not None: + pulumi.set(__self__, "cooldown_period", cooldown_period) + if fallback is not None: + pulumi.set(__self__, "fallback", fallback) + if idle_replica_count is not None: + pulumi.set(__self__, "idle_replica_count", idle_replica_count) + if initial_cooldown_period is not None: + pulumi.set(__self__, "initial_cooldown_period", initial_cooldown_period) + if max_replica_count is not None: + pulumi.set(__self__, "max_replica_count", max_replica_count) + if min_replica_count is not None: + pulumi.set(__self__, "min_replica_count", min_replica_count) + if polling_interval is not None: + pulumi.set(__self__, "polling_interval", polling_interval) + if triggers is not None: + pulumi.set(__self__, "triggers", triggers) + + @_builtins.property + @pulumi.getter + def advanced(self) -> Optional['outputs.KedaAdvancedArgs']: """ - :param _builtins.str key: The label key that the selector applies to. - :param _builtins.str operator: Operator relating the key and values. One of: 'In', 'NotIn', 'Exists', 'DoesNotExist'. - :param Sequence[_builtins.str] values: Array of string values. Required for 'In' and 'NotIn' operators. + Advanced ScaledObject behavior configuration. """ - if key is not None: - pulumi.set(__self__, "key", key) - if operator is not None: - pulumi.set(__self__, "operator", operator) - if values is not None: - pulumi.set(__self__, "values", values) + return pulumi.get(self, "advanced") @_builtins.property - @pulumi.getter - def key(self) -> Optional[_builtins.str]: + @pulumi.getter(name="cooldownPeriod") + def cooldown_period(self) -> Optional[_builtins.int]: """ - The label key that the selector applies to. + Seconds to wait after the last trigger reports active=false before scaling to minReplicaCount. Example: 300. """ - return pulumi.get(self, "key") + return pulumi.get(self, "cooldown_period") @_builtins.property @pulumi.getter - def operator(self) -> Optional[_builtins.str]: + def fallback(self) -> Optional['outputs.KedaFallbackArgs']: """ - Operator relating the key and values. One of: 'In', 'NotIn', 'Exists', 'DoesNotExist'. + Replica fallback configuration when KEDA metrics are unavailable. """ - return pulumi.get(self, "operator") + return pulumi.get(self, "fallback") + + @_builtins.property + @pulumi.getter(name="idleReplicaCount") + def idle_replica_count(self) -> Optional[_builtins.int]: + """ + Replica count to scale to when idle. Must be less than minReplicaCount. Example: 0. + """ + return pulumi.get(self, "idle_replica_count") + + @_builtins.property + @pulumi.getter(name="initialCooldownPeriod") + def initial_cooldown_period(self) -> Optional[_builtins.int]: + """ + Cooldown period applied only during the initial scaling of the ScaledObject. Example: 0. + """ + return pulumi.get(self, "initial_cooldown_period") + + @_builtins.property + @pulumi.getter(name="maxReplicaCount") + def max_replica_count(self) -> Optional[_builtins.int]: + """ + Maximum number of replicas. Example: 10. + """ + return pulumi.get(self, "max_replica_count") + + @_builtins.property + @pulumi.getter(name="minReplicaCount") + def min_replica_count(self) -> Optional[_builtins.int]: + """ + Minimum number of replicas. Example: 0. + """ + return pulumi.get(self, "min_replica_count") + + @_builtins.property + @pulumi.getter(name="pollingInterval") + def polling_interval(self) -> Optional[_builtins.int]: + """ + Seconds between checks of trigger metrics. Example: 30. + """ + return pulumi.get(self, "polling_interval") @_builtins.property @pulumi.getter - def values(self) -> Optional[Sequence[_builtins.str]]: + def triggers(self) -> Optional[Sequence['outputs.KedaTriggerArgs']]: """ - Array of string values. Required for 'In' and 'NotIn' operators. + KEDA scaler triggers driving this ScaledObject. """ - return pulumi.get(self, "values") + return pulumi.get(self, "triggers") @pulumi.output_type -class MetadataOptionsArgs(dict): +class KedaTriggerArgs(dict): @staticmethod def __key_warning(key: str): suggest = None - if key == "httpEndpoint": - suggest = "http_endpoint" - elif key == "httpProtocolIpv6": - suggest = "http_protocol_ipv6" - elif key == "httpPutResponseHopLimit": - suggest = "http_put_response_hop_limit" - elif key == "httpTokens": - suggest = "http_tokens" + if key == "authenticationRef": + suggest = "authentication_ref" + elif key == "metricType": + suggest = "metric_type" + elif key == "useCachedMetrics": + suggest = "use_cached_metrics" if suggest: - pulumi.log.warn(f"Key '{key}' not found in MetadataOptionsArgs. Access the value via the '{suggest}' property getter instead.") + pulumi.log.warn(f"Key '{key}' not found in KedaTriggerArgs. Access the value via the '{suggest}' property getter instead.") def __getitem__(self, key: str) -> Any: - MetadataOptionsArgs.__key_warning(key) + KedaTriggerArgs.__key_warning(key) return super().__getitem__(key) def get(self, key: str, default = None) -> Any: - MetadataOptionsArgs.__key_warning(key) + KedaTriggerArgs.__key_warning(key) return super().get(key, default) def __init__(__self__, *, - http_endpoint: Optional[_builtins.str] = None, - http_protocol_ipv6: Optional[_builtins.str] = None, - http_put_response_hop_limit: Optional[_builtins.int] = None, - http_tokens: Optional[_builtins.str] = None): + type: _builtins.str, + authentication_ref: Optional['outputs.KedaAuthenticationRefArgs'] = None, + metadata: Optional[Mapping[str, _builtins.str]] = None, + metric_type: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None, + use_cached_metrics: Optional[_builtins.bool] = None): """ - :param _builtins.str http_endpoint: Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. - :param _builtins.str http_protocol_ipv6: Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. - :param _builtins.int http_put_response_hop_limit: HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. - :param _builtins.str http_tokens: Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. + :param _builtins.str type: KEDA scaler type. Example: 'prometheus'. + :param 'KedaAuthenticationRefArgs' authentication_ref: Reference to a TriggerAuthentication or ClusterTriggerAuthentication for this trigger. + :param Mapping[str, _builtins.str] metadata: Scaler-specific configuration key-value pairs. Example: {"serverAddress": "http://prometheus:9090", "query": "sum(rate(http_requests_total[2m]))"}. + :param _builtins.str metric_type: Metric target type. One of: 'Value', 'AverageValue', 'Utilization'. Example: 'AverageValue'. + :param _builtins.str name: Optional trigger name, used to disambiguate multiple triggers of the same type. Example: 'requests-per-second'. + :param _builtins.bool use_cached_metrics: Use KEDA's metric caching for this trigger. Example: false. """ - if http_endpoint is not None: - pulumi.set(__self__, "http_endpoint", http_endpoint) - if http_protocol_ipv6 is not None: - pulumi.set(__self__, "http_protocol_ipv6", http_protocol_ipv6) - if http_put_response_hop_limit is not None: - pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit) - if http_tokens is not None: - pulumi.set(__self__, "http_tokens", http_tokens) + pulumi.set(__self__, "type", type) + if authentication_ref is not None: + pulumi.set(__self__, "authentication_ref", authentication_ref) + if metadata is not None: + pulumi.set(__self__, "metadata", metadata) + if metric_type is not None: + pulumi.set(__self__, "metric_type", metric_type) + if name is not None: + pulumi.set(__self__, "name", name) + if use_cached_metrics is not None: + pulumi.set(__self__, "use_cached_metrics", use_cached_metrics) @_builtins.property - @pulumi.getter(name="httpEndpoint") - def http_endpoint(self) -> Optional[_builtins.str]: + @pulumi.getter + def type(self) -> _builtins.str: """ - Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. + KEDA scaler type. Example: 'prometheus'. """ - return pulumi.get(self, "http_endpoint") + return pulumi.get(self, "type") @_builtins.property - @pulumi.getter(name="httpProtocolIpv6") - def http_protocol_ipv6(self) -> Optional[_builtins.str]: + @pulumi.getter(name="authenticationRef") + def authentication_ref(self) -> Optional['outputs.KedaAuthenticationRefArgs']: """ - Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. + Reference to a TriggerAuthentication or ClusterTriggerAuthentication for this trigger. """ - return pulumi.get(self, "http_protocol_ipv6") + return pulumi.get(self, "authentication_ref") @_builtins.property - @pulumi.getter(name="httpPutResponseHopLimit") - def http_put_response_hop_limit(self) -> Optional[_builtins.int]: + @pulumi.getter + def metadata(self) -> Optional[Mapping[str, _builtins.str]]: """ - HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. + Scaler-specific configuration key-value pairs. Example: {"serverAddress": "http://prometheus:9090", "query": "sum(rate(http_requests_total[2m]))"}. """ - return pulumi.get(self, "http_put_response_hop_limit") + return pulumi.get(self, "metadata") @_builtins.property - @pulumi.getter(name="httpTokens") - def http_tokens(self) -> Optional[_builtins.str]: - """ - Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. - """ - return pulumi.get(self, "http_tokens") - - -@pulumi.output_type -class NamePatternArgs(dict): - def __init__(__self__, *, - flags: Optional[_builtins.str] = None, - pattern: Optional[_builtins.str] = None): + @pulumi.getter(name="metricType") + def metric_type(self) -> Optional[_builtins.str]: """ - :param _builtins.str flags: Optional regex flags (e.g. 'i' for case-insensitive). - :param _builtins.str pattern: Regular expression pattern to match workload names. + Metric target type. One of: 'Value', 'AverageValue', 'Utilization'. Example: 'AverageValue'. """ - if flags is not None: - pulumi.set(__self__, "flags", flags) - if pattern is not None: - pulumi.set(__self__, "pattern", pattern) + return pulumi.get(self, "metric_type") @_builtins.property @pulumi.getter - def flags(self) -> Optional[_builtins.str]: + def name(self) -> Optional[_builtins.str]: """ - Optional regex flags (e.g. 'i' for case-insensitive). + Optional trigger name, used to disambiguate multiple triggers of the same type. Example: 'requests-per-second'. """ - return pulumi.get(self, "flags") + return pulumi.get(self, "name") @_builtins.property - @pulumi.getter - def pattern(self) -> Optional[_builtins.str]: + @pulumi.getter(name="useCachedMetrics") + def use_cached_metrics(self) -> Optional[_builtins.bool]: """ - Regular expression pattern to match workload names. + Use KEDA's metric caching for this trigger. Example: false. """ - return pulumi.get(self, "pattern") + return pulumi.get(self, "use_cached_metrics") + + +@pulumi.output_type +class KubeletConfigurationArgs(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "clusterDns": + suggest = "cluster_dns" + elif key == "cpuCfsQuota": + suggest = "cpu_cfs_quota" + elif key == "evictionHard": + suggest = "eviction_hard" + elif key == "evictionMaxPodGracePeriod": + suggest = "eviction_max_pod_grace_period" + elif key == "evictionSoft": + suggest = "eviction_soft" + elif key == "evictionSoftGracePeriod": + suggest = "eviction_soft_grace_period" + elif key == "imageGcHighThresholdPercent": + suggest = "image_gc_high_threshold_percent" + elif key == "imageGcLowThresholdPercent": + suggest = "image_gc_low_threshold_percent" + elif key == "kubeReserved": + suggest = "kube_reserved" + elif key == "maxPods": + suggest = "max_pods" + elif key == "podsPerCore": + suggest = "pods_per_core" + elif key == "systemReserved": + suggest = "system_reserved" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in KubeletConfigurationArgs. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + KubeletConfigurationArgs.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + KubeletConfigurationArgs.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cluster_dns: Optional[Sequence[_builtins.str]] = None, + cpu_cfs_quota: Optional[_builtins.bool] = None, + eviction_hard: Optional[Mapping[str, _builtins.str]] = None, + eviction_max_pod_grace_period: Optional[_builtins.int] = None, + eviction_soft: Optional[Mapping[str, _builtins.str]] = None, + eviction_soft_grace_period: Optional[Mapping[str, _builtins.str]] = None, + image_gc_high_threshold_percent: Optional[_builtins.int] = None, + image_gc_low_threshold_percent: Optional[_builtins.int] = None, + kube_reserved: Optional[Mapping[str, _builtins.str]] = None, + max_pods: Optional[_builtins.int] = None, + pods_per_core: Optional[_builtins.int] = None, + system_reserved: Optional[Mapping[str, _builtins.str]] = None): + """ + :param Sequence[_builtins.str] cluster_dns: DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. + :param _builtins.bool cpu_cfs_quota: Whether to enforce CPU CFS quota limits for containers. Example: true. + :param Mapping[str, _builtins.str] eviction_hard: Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. + :param _builtins.int eviction_max_pod_grace_period: Maximum pod termination grace period (seconds) during eviction. Example: 90. + :param Mapping[str, _builtins.str] eviction_soft: Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. + :param Mapping[str, _builtins.str] eviction_soft_grace_period: Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. + :param _builtins.int image_gc_high_threshold_percent: Disk usage % that triggers image garbage collection. Example: 85. + :param _builtins.int image_gc_low_threshold_percent: Disk usage % at which image GC stops freeing space. Example: 70. + :param Mapping[str, _builtins.str] kube_reserved: Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. + :param _builtins.int max_pods: Maximum number of pods allowed per node. Example: 110. + :param _builtins.int pods_per_core: Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. + :param Mapping[str, _builtins.str] system_reserved: Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. + """ + if cluster_dns is not None: + pulumi.set(__self__, "cluster_dns", cluster_dns) + if cpu_cfs_quota is not None: + pulumi.set(__self__, "cpu_cfs_quota", cpu_cfs_quota) + if eviction_hard is not None: + pulumi.set(__self__, "eviction_hard", eviction_hard) + if eviction_max_pod_grace_period is not None: + pulumi.set(__self__, "eviction_max_pod_grace_period", eviction_max_pod_grace_period) + if eviction_soft is not None: + pulumi.set(__self__, "eviction_soft", eviction_soft) + if eviction_soft_grace_period is not None: + pulumi.set(__self__, "eviction_soft_grace_period", eviction_soft_grace_period) + if image_gc_high_threshold_percent is not None: + pulumi.set(__self__, "image_gc_high_threshold_percent", image_gc_high_threshold_percent) + if image_gc_low_threshold_percent is not None: + pulumi.set(__self__, "image_gc_low_threshold_percent", image_gc_low_threshold_percent) + if kube_reserved is not None: + pulumi.set(__self__, "kube_reserved", kube_reserved) + if max_pods is not None: + pulumi.set(__self__, "max_pods", max_pods) + if pods_per_core is not None: + pulumi.set(__self__, "pods_per_core", pods_per_core) + if system_reserved is not None: + pulumi.set(__self__, "system_reserved", system_reserved) + + @_builtins.property + @pulumi.getter(name="clusterDns") + def cluster_dns(self) -> Optional[Sequence[_builtins.str]]: + """ + DNS server IP addresses passed to kubelet. Example: ["10.96.0.10"]. + """ + return pulumi.get(self, "cluster_dns") + + @_builtins.property + @pulumi.getter(name="cpuCfsQuota") + def cpu_cfs_quota(self) -> Optional[_builtins.bool]: + """ + Whether to enforce CPU CFS quota limits for containers. Example: true. + """ + return pulumi.get(self, "cpu_cfs_quota") + + @_builtins.property + @pulumi.getter(name="evictionHard") + def eviction_hard(self) -> Optional[Mapping[str, _builtins.str]]: + """ + Hard eviction thresholds — pods are evicted immediately when crossed. Example: {"memory.available": "100Mi", "nodefs.available": "10%"}. + """ + return pulumi.get(self, "eviction_hard") + + @_builtins.property + @pulumi.getter(name="evictionMaxPodGracePeriod") + def eviction_max_pod_grace_period(self) -> Optional[_builtins.int]: + """ + Maximum pod termination grace period (seconds) during eviction. Example: 90. + """ + return pulumi.get(self, "eviction_max_pod_grace_period") + + @_builtins.property + @pulumi.getter(name="evictionSoft") + def eviction_soft(self) -> Optional[Mapping[str, _builtins.str]]: + """ + Soft eviction thresholds — eviction begins after the grace period expires. Example: {"memory.available": "200Mi"}. + """ + return pulumi.get(self, "eviction_soft") + + @_builtins.property + @pulumi.getter(name="evictionSoftGracePeriod") + def eviction_soft_grace_period(self) -> Optional[Mapping[str, _builtins.str]]: + """ + Grace period before acting on a soft eviction threshold. Example: {"memory.available": "90s"}. + """ + return pulumi.get(self, "eviction_soft_grace_period") + + @_builtins.property + @pulumi.getter(name="imageGcHighThresholdPercent") + def image_gc_high_threshold_percent(self) -> Optional[_builtins.int]: + """ + Disk usage % that triggers image garbage collection. Example: 85. + """ + return pulumi.get(self, "image_gc_high_threshold_percent") + + @_builtins.property + @pulumi.getter(name="imageGcLowThresholdPercent") + def image_gc_low_threshold_percent(self) -> Optional[_builtins.int]: + """ + Disk usage % at which image GC stops freeing space. Example: 70. + """ + return pulumi.get(self, "image_gc_low_threshold_percent") + + @_builtins.property + @pulumi.getter(name="kubeReserved") + def kube_reserved(self) -> Optional[Mapping[str, _builtins.str]]: + """ + Resources reserved for Kubernetes system components (kubelet, kube-proxy). Example: {"cpu": "100m", "memory": "100Mi"}. + """ + return pulumi.get(self, "kube_reserved") + + @_builtins.property + @pulumi.getter(name="maxPods") + def max_pods(self) -> Optional[_builtins.int]: + """ + Maximum number of pods allowed per node. Example: 110. + """ + return pulumi.get(self, "max_pods") + + @_builtins.property + @pulumi.getter(name="podsPerCore") + def pods_per_core(self) -> Optional[_builtins.int]: + """ + Maximum pods per CPU core; multiplied by node core count for effective max. Example: 10. + """ + return pulumi.get(self, "pods_per_core") + + @_builtins.property + @pulumi.getter(name="systemReserved") + def system_reserved(self) -> Optional[Mapping[str, _builtins.str]]: + """ + Resources reserved for OS system daemons (not Kubernetes). Example: {"cpu": "100m", "memory": "100Mi"}. + """ + return pulumi.get(self, "system_reserved") + + +@pulumi.output_type +class LabelSelectorArgs(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "matchExpressions": + suggest = "match_expressions" + elif key == "matchLabels": + suggest = "match_labels" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in LabelSelectorArgs. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + LabelSelectorArgs.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + LabelSelectorArgs.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + match_expressions: Optional[Sequence['outputs.LabelSelectorRequirementArgs']] = None, + match_labels: Optional[Mapping[str, _builtins.str]] = None): + """ + :param Sequence['LabelSelectorRequirementArgs'] match_expressions: List of label selector requirements joined by AND. + :param Mapping[str, _builtins.str] match_labels: Map of label key-value pairs that must all match exactly. + """ + if match_expressions is not None: + pulumi.set(__self__, "match_expressions", match_expressions) + if match_labels is not None: + pulumi.set(__self__, "match_labels", match_labels) + + @_builtins.property + @pulumi.getter(name="matchExpressions") + def match_expressions(self) -> Optional[Sequence['outputs.LabelSelectorRequirementArgs']]: + """ + List of label selector requirements joined by AND. + """ + return pulumi.get(self, "match_expressions") + + @_builtins.property + @pulumi.getter(name="matchLabels") + def match_labels(self) -> Optional[Mapping[str, _builtins.str]]: + """ + Map of label key-value pairs that must all match exactly. + """ + return pulumi.get(self, "match_labels") + + +@pulumi.output_type +class LabelSelectorRequirementArgs(dict): + def __init__(__self__, *, + key: Optional[_builtins.str] = None, + operator: Optional[_builtins.str] = None, + values: Optional[Sequence[_builtins.str]] = None): + """ + :param _builtins.str key: The label key that the selector applies to. + :param _builtins.str operator: Operator relating the key and values. One of: 'In', 'NotIn', 'Exists', 'DoesNotExist'. + :param Sequence[_builtins.str] values: Array of string values. Required for 'In' and 'NotIn' operators. + """ + if key is not None: + pulumi.set(__self__, "key", key) + if operator is not None: + pulumi.set(__self__, "operator", operator) + if values is not None: + pulumi.set(__self__, "values", values) + + @_builtins.property + @pulumi.getter + def key(self) -> Optional[_builtins.str]: + """ + The label key that the selector applies to. + """ + return pulumi.get(self, "key") + + @_builtins.property + @pulumi.getter + def operator(self) -> Optional[_builtins.str]: + """ + Operator relating the key and values. One of: 'In', 'NotIn', 'Exists', 'DoesNotExist'. + """ + return pulumi.get(self, "operator") + + @_builtins.property + @pulumi.getter + def values(self) -> Optional[Sequence[_builtins.str]]: + """ + Array of string values. Required for 'In' and 'NotIn' operators. + """ + return pulumi.get(self, "values") + + +@pulumi.output_type +class MetadataOptionsArgs(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "httpEndpoint": + suggest = "http_endpoint" + elif key == "httpProtocolIpv6": + suggest = "http_protocol_ipv6" + elif key == "httpPutResponseHopLimit": + suggest = "http_put_response_hop_limit" + elif key == "httpTokens": + suggest = "http_tokens" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in MetadataOptionsArgs. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + MetadataOptionsArgs.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + MetadataOptionsArgs.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + http_endpoint: Optional[_builtins.str] = None, + http_protocol_ipv6: Optional[_builtins.str] = None, + http_put_response_hop_limit: Optional[_builtins.int] = None, + http_tokens: Optional[_builtins.str] = None): + """ + :param _builtins.str http_endpoint: Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. + :param _builtins.str http_protocol_ipv6: Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. + :param _builtins.int http_put_response_hop_limit: HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. + :param _builtins.str http_tokens: Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. + """ + if http_endpoint is not None: + pulumi.set(__self__, "http_endpoint", http_endpoint) + if http_protocol_ipv6 is not None: + pulumi.set(__self__, "http_protocol_ipv6", http_protocol_ipv6) + if http_put_response_hop_limit is not None: + pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit) + if http_tokens is not None: + pulumi.set(__self__, "http_tokens", http_tokens) + + @_builtins.property + @pulumi.getter(name="httpEndpoint") + def http_endpoint(self) -> Optional[_builtins.str]: + """ + Enable or disable the EC2 instance metadata endpoint. One of: 'enabled', 'disabled'. Example: 'enabled'. + """ + return pulumi.get(self, "http_endpoint") + + @_builtins.property + @pulumi.getter(name="httpProtocolIpv6") + def http_protocol_ipv6(self) -> Optional[_builtins.str]: + """ + Enable IPv6 for the metadata endpoint. One of: 'enabled', 'disabled'. Example: 'disabled'. + """ + return pulumi.get(self, "http_protocol_ipv6") + + @_builtins.property + @pulumi.getter(name="httpPutResponseHopLimit") + def http_put_response_hop_limit(self) -> Optional[_builtins.int]: + """ + HTTP PUT response hop limit for metadata requests (1-64). Set to 1 to block pod-level IMDS access. Example: 1. + """ + return pulumi.get(self, "http_put_response_hop_limit") + + @_builtins.property + @pulumi.getter(name="httpTokens") + def http_tokens(self) -> Optional[_builtins.str]: + """ + Whether to require IMDSv2 session tokens (recommended). One of: 'optional', 'required'. Example: 'required'. + """ + return pulumi.get(self, "http_tokens") + + +@pulumi.output_type +class NamePatternArgs(dict): + def __init__(__self__, *, + flags: Optional[_builtins.str] = None, + pattern: Optional[_builtins.str] = None): + """ + :param _builtins.str flags: Optional regex flags (e.g. 'i' for case-insensitive). + :param _builtins.str pattern: Regular expression pattern to match workload names. + """ + if flags is not None: + pulumi.set(__self__, "flags", flags) + if pattern is not None: + pulumi.set(__self__, "pattern", pattern) + + @_builtins.property + @pulumi.getter + def flags(self) -> Optional[_builtins.str]: + """ + Optional regex flags (e.g. 'i' for case-insensitive). + """ + return pulumi.get(self, "flags") + + @_builtins.property + @pulumi.getter + def pattern(self) -> Optional[_builtins.str]: + """ + Regular expression pattern to match workload names. + """ + return pulumi.get(self, "pattern") + + +@pulumi.output_type +class OCIBootConfigArgs(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "bootVolumeSizeInGbs": + suggest = "boot_volume_size_in_gbs" + elif key == "bootVolumeVpusPerGb": + suggest = "boot_volume_vpus_per_gb" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in OCIBootConfigArgs. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + OCIBootConfigArgs.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + OCIBootConfigArgs.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + boot_volume_size_in_gbs: Optional[_builtins.int] = None, + boot_volume_vpus_per_gb: Optional[_builtins.int] = None): + """ + :param _builtins.int boot_volume_size_in_gbs: Boot volume size in GB. Example: 100. + :param _builtins.int boot_volume_vpus_per_gb: Boot volume performance units per GB. Example: 10. + """ + if boot_volume_size_in_gbs is not None: + pulumi.set(__self__, "boot_volume_size_in_gbs", boot_volume_size_in_gbs) + if boot_volume_vpus_per_gb is not None: + pulumi.set(__self__, "boot_volume_vpus_per_gb", boot_volume_vpus_per_gb) + + @_builtins.property + @pulumi.getter(name="bootVolumeSizeInGbs") + def boot_volume_size_in_gbs(self) -> Optional[_builtins.int]: + """ + Boot volume size in GB. Example: 100. + """ + return pulumi.get(self, "boot_volume_size_in_gbs") + + @_builtins.property + @pulumi.getter(name="bootVolumeVpusPerGb") + def boot_volume_vpus_per_gb(self) -> Optional[_builtins.int]: + """ + Boot volume performance units per GB. Example: 10. + """ + return pulumi.get(self, "boot_volume_vpus_per_gb") + + +@pulumi.output_type +class OCIImageSelectorTermArgs(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "compartmentId": + suggest = "compartment_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in OCIImageSelectorTermArgs. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + OCIImageSelectorTermArgs.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + OCIImageSelectorTermArgs.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compartment_id: Optional[_builtins.str] = None, + id: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None): + """ + :param _builtins.str compartment_id: OCID of the compartment containing the image. Example: 'ocid1.compartment.oc1..aaaaaaaa'. + :param _builtins.str id: Explicit OCI image OCID. Example: 'ocid1.image.oc1..aaaaaaaa'. + :param _builtins.str name: OCI image display name filter. Example: 'Oracle-Linux-8.9'. + """ + if compartment_id is not None: + pulumi.set(__self__, "compartment_id", compartment_id) + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter(name="compartmentId") + def compartment_id(self) -> Optional[_builtins.str]: + """ + OCID of the compartment containing the image. Example: 'ocid1.compartment.oc1..aaaaaaaa'. + """ + return pulumi.get(self, "compartment_id") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + """ + Explicit OCI image OCID. Example: 'ocid1.image.oc1..aaaaaaaa'. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + OCI image display name filter. Example: 'Oracle-Linux-8.9'. + """ + return pulumi.get(self, "name") + + +@pulumi.output_type +class OCILaunchOptionsArgs(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "bootVolumeType": + suggest = "boot_volume_type" + elif key == "isConsistentVolumeNamingEnabled": + suggest = "is_consistent_volume_naming_enabled" + elif key == "networkType": + suggest = "network_type" + elif key == "remoteDataVolumeType": + suggest = "remote_data_volume_type" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in OCILaunchOptionsArgs. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + OCILaunchOptionsArgs.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + OCILaunchOptionsArgs.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + boot_volume_type: Optional[_builtins.str] = None, + firmware: Optional[_builtins.str] = None, + is_consistent_volume_naming_enabled: Optional[_builtins.bool] = None, + network_type: Optional[_builtins.str] = None, + remote_data_volume_type: Optional[_builtins.str] = None): + """ + :param _builtins.str boot_volume_type: Emulation type for the boot volume. Example: 'PARAVIRTUALIZED'. + :param _builtins.str firmware: Firmware used to boot the instance. Example: 'UEFI_64'. + :param _builtins.bool is_consistent_volume_naming_enabled: Whether consistent volume naming is enabled for the instance. Example: true. + :param _builtins.str network_type: Emulation type for the network interface. Example: 'PARAVIRTUALIZED'. + :param _builtins.str remote_data_volume_type: Emulation type for remote data volumes. Example: 'PARAVIRTUALIZED'. + """ + if boot_volume_type is not None: + pulumi.set(__self__, "boot_volume_type", boot_volume_type) + if firmware is not None: + pulumi.set(__self__, "firmware", firmware) + if is_consistent_volume_naming_enabled is not None: + pulumi.set(__self__, "is_consistent_volume_naming_enabled", is_consistent_volume_naming_enabled) + if network_type is not None: + pulumi.set(__self__, "network_type", network_type) + if remote_data_volume_type is not None: + pulumi.set(__self__, "remote_data_volume_type", remote_data_volume_type) + + @_builtins.property + @pulumi.getter(name="bootVolumeType") + def boot_volume_type(self) -> Optional[_builtins.str]: + """ + Emulation type for the boot volume. Example: 'PARAVIRTUALIZED'. + """ + return pulumi.get(self, "boot_volume_type") + + @_builtins.property + @pulumi.getter + def firmware(self) -> Optional[_builtins.str]: + """ + Firmware used to boot the instance. Example: 'UEFI_64'. + """ + return pulumi.get(self, "firmware") + + @_builtins.property + @pulumi.getter(name="isConsistentVolumeNamingEnabled") + def is_consistent_volume_naming_enabled(self) -> Optional[_builtins.bool]: + """ + Whether consistent volume naming is enabled for the instance. Example: true. + """ + return pulumi.get(self, "is_consistent_volume_naming_enabled") + + @_builtins.property + @pulumi.getter(name="networkType") + def network_type(self) -> Optional[_builtins.str]: + """ + Emulation type for the network interface. Example: 'PARAVIRTUALIZED'. + """ + return pulumi.get(self, "network_type") + + @_builtins.property + @pulumi.getter(name="remoteDataVolumeType") + def remote_data_volume_type(self) -> Optional[_builtins.str]: + """ + Emulation type for remote data volumes. Example: 'PARAVIRTUALIZED'. + """ + return pulumi.get(self, "remote_data_volume_type") + + +@pulumi.output_type +class OCINodeClassSpecArgs(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "agentList": + suggest = "agent_list" + elif key == "blockDevices": + suggest = "block_devices" + elif key == "bootConfig": + suggest = "boot_config" + elif key == "freeFormTags": + suggest = "free_form_tags" + elif key == "imageFamily": + suggest = "image_family" + elif key == "imageSelector": + suggest = "image_selector" + elif key == "launchOptions": + suggest = "launch_options" + elif key == "metaData": + suggest = "meta_data" + elif key == "preInstallScript": + suggest = "pre_install_script" + elif key == "securityGroupSelector": + suggest = "security_group_selector" + elif key == "subnetSelector": + suggest = "subnet_selector" + elif key == "userData": + suggest = "user_data" + elif key == "vcnId": + suggest = "vcn_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in OCINodeClassSpecArgs. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + OCINodeClassSpecArgs.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + OCINodeClassSpecArgs.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + agent_list: Optional[Sequence[_builtins.str]] = None, + block_devices: Optional[Sequence['outputs.OCIVolumeAttributesArgs']] = None, + boot_config: Optional['outputs.OCIBootConfigArgs'] = None, + free_form_tags: Optional[Mapping[str, _builtins.str]] = None, + image_family: Optional[_builtins.str] = None, + image_selector: Optional[Sequence['outputs.OCIImageSelectorTermArgs']] = None, + launch_options: Optional['outputs.OCILaunchOptionsArgs'] = None, + meta_data: Optional[Mapping[str, _builtins.str]] = None, + pre_install_script: Optional[_builtins.str] = None, + security_group_selector: Optional[Sequence['outputs.OCISecurityGroupSelectorTermArgs']] = None, + subnet_selector: Optional[Sequence['outputs.OCISubnetSelectorTermArgs']] = None, + tags: Optional[Mapping[str, _builtins.str]] = None, + user_data: Optional[_builtins.str] = None, + vcn_id: Optional[_builtins.str] = None): + """ + :param Sequence[_builtins.str] agent_list: OCI compute instance agent plugins to enable. Example: ["Compute Instance Monitoring"]. + :param Sequence['OCIVolumeAttributesArgs'] block_devices: Additional block volumes attached to provisioned nodes. + :param 'OCIBootConfigArgs' boot_config: Boot volume configuration for provisioned nodes. + :param Mapping[str, _builtins.str] free_form_tags: OCI free-form tags applied to all resources created by this node class. Example: {"environment": "production"}. + :param _builtins.str image_family: OCI node image family shorthand used when no imageSelector is specified. Example: 'Oracle-Linux-8'. + :param Sequence['OCIImageSelectorTermArgs'] image_selector: Selectors for the images used to launch nodes. Example: [{name: "Oracle-Linux-8.9"}]. + :param 'OCILaunchOptionsArgs' launch_options: Instance launch options controlling firmware and network/volume emulation type. + :param Mapping[str, _builtins.str] meta_data: OCI instance metadata applied to provisioned nodes. Example: {"ssh_authorized_keys": "ssh-rsa ..."}. + :param _builtins.str pre_install_script: Script executed before node bootstrap. Example: '#!/bin/bash\\necho pre-install'. + :param Sequence['OCISecurityGroupSelectorTermArgs'] security_group_selector: Selectors for network security groups attached to provisioned nodes. + :param Sequence['OCISubnetSelectorTermArgs'] subnet_selector: Selectors for the subnets nodes will be launched into. + :param Mapping[str, _builtins.str] tags: OCI defined tags applied to all resources created by this node class. + :param _builtins.str user_data: Custom cloud-init user data merged into the node launch config (base64 or plain text). Example: '#!/bin/bash\\necho hello'. + :param _builtins.str vcn_id: OCID of the VCN nodes will be launched into. Example: 'ocid1.vcn.oc1..aaaaaaaa'. + """ + if agent_list is not None: + pulumi.set(__self__, "agent_list", agent_list) + if block_devices is not None: + pulumi.set(__self__, "block_devices", block_devices) + if boot_config is not None: + pulumi.set(__self__, "boot_config", boot_config) + if free_form_tags is not None: + pulumi.set(__self__, "free_form_tags", free_form_tags) + if image_family is not None: + pulumi.set(__self__, "image_family", image_family) + if image_selector is not None: + pulumi.set(__self__, "image_selector", image_selector) + if launch_options is not None: + pulumi.set(__self__, "launch_options", launch_options) + if meta_data is not None: + pulumi.set(__self__, "meta_data", meta_data) + if pre_install_script is not None: + pulumi.set(__self__, "pre_install_script", pre_install_script) + if security_group_selector is not None: + pulumi.set(__self__, "security_group_selector", security_group_selector) + if subnet_selector is not None: + pulumi.set(__self__, "subnet_selector", subnet_selector) + if tags is not None: + pulumi.set(__self__, "tags", tags) + if user_data is not None: + pulumi.set(__self__, "user_data", user_data) + if vcn_id is not None: + pulumi.set(__self__, "vcn_id", vcn_id) + + @_builtins.property + @pulumi.getter(name="agentList") + def agent_list(self) -> Optional[Sequence[_builtins.str]]: + """ + OCI compute instance agent plugins to enable. Example: ["Compute Instance Monitoring"]. + """ + return pulumi.get(self, "agent_list") + + @_builtins.property + @pulumi.getter(name="blockDevices") + def block_devices(self) -> Optional[Sequence['outputs.OCIVolumeAttributesArgs']]: + """ + Additional block volumes attached to provisioned nodes. + """ + return pulumi.get(self, "block_devices") + + @_builtins.property + @pulumi.getter(name="bootConfig") + def boot_config(self) -> Optional['outputs.OCIBootConfigArgs']: + """ + Boot volume configuration for provisioned nodes. + """ + return pulumi.get(self, "boot_config") + + @_builtins.property + @pulumi.getter(name="freeFormTags") + def free_form_tags(self) -> Optional[Mapping[str, _builtins.str]]: + """ + OCI free-form tags applied to all resources created by this node class. Example: {"environment": "production"}. + """ + return pulumi.get(self, "free_form_tags") + + @_builtins.property + @pulumi.getter(name="imageFamily") + def image_family(self) -> Optional[_builtins.str]: + """ + OCI node image family shorthand used when no imageSelector is specified. Example: 'Oracle-Linux-8'. + """ + return pulumi.get(self, "image_family") + + @_builtins.property + @pulumi.getter(name="imageSelector") + def image_selector(self) -> Optional[Sequence['outputs.OCIImageSelectorTermArgs']]: + """ + Selectors for the images used to launch nodes. Example: [{name: "Oracle-Linux-8.9"}]. + """ + return pulumi.get(self, "image_selector") + + @_builtins.property + @pulumi.getter(name="launchOptions") + def launch_options(self) -> Optional['outputs.OCILaunchOptionsArgs']: + """ + Instance launch options controlling firmware and network/volume emulation type. + """ + return pulumi.get(self, "launch_options") + + @_builtins.property + @pulumi.getter(name="metaData") + def meta_data(self) -> Optional[Mapping[str, _builtins.str]]: + """ + OCI instance metadata applied to provisioned nodes. Example: {"ssh_authorized_keys": "ssh-rsa ..."}. + """ + return pulumi.get(self, "meta_data") + + @_builtins.property + @pulumi.getter(name="preInstallScript") + def pre_install_script(self) -> Optional[_builtins.str]: + """ + Script executed before node bootstrap. Example: '#!/bin/bash\\necho pre-install'. + """ + return pulumi.get(self, "pre_install_script") + + @_builtins.property + @pulumi.getter(name="securityGroupSelector") + def security_group_selector(self) -> Optional[Sequence['outputs.OCISecurityGroupSelectorTermArgs']]: + """ + Selectors for network security groups attached to provisioned nodes. + """ + return pulumi.get(self, "security_group_selector") + + @_builtins.property + @pulumi.getter(name="subnetSelector") + def subnet_selector(self) -> Optional[Sequence['outputs.OCISubnetSelectorTermArgs']]: + """ + Selectors for the subnets nodes will be launched into. + """ + return pulumi.get(self, "subnet_selector") + + @_builtins.property + @pulumi.getter + def tags(self) -> Optional[Mapping[str, _builtins.str]]: + """ + OCI defined tags applied to all resources created by this node class. + """ + return pulumi.get(self, "tags") + + @_builtins.property + @pulumi.getter(name="userData") + def user_data(self) -> Optional[_builtins.str]: + """ + Custom cloud-init user data merged into the node launch config (base64 or plain text). Example: '#!/bin/bash\\necho hello'. + """ + return pulumi.get(self, "user_data") + + @_builtins.property + @pulumi.getter(name="vcnId") + def vcn_id(self) -> Optional[_builtins.str]: + """ + OCID of the VCN nodes will be launched into. Example: 'ocid1.vcn.oc1..aaaaaaaa'. + """ + return pulumi.get(self, "vcn_id") + + +@pulumi.output_type +class OCISecurityGroupSelectorTermArgs(dict): + def __init__(__self__, *, + id: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None): + """ + :param _builtins.str id: Explicit OCI network security group OCID. Example: 'ocid1.networksecuritygroup.oc1..aaaaaaaa'. + :param _builtins.str name: OCI network security group display name filter. Example: 'node-nsg'. + """ + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + """ + Explicit OCI network security group OCID. Example: 'ocid1.networksecuritygroup.oc1..aaaaaaaa'. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + OCI network security group display name filter. Example: 'node-nsg'. + """ + return pulumi.get(self, "name") + + +@pulumi.output_type +class OCISubnetSelectorTermArgs(dict): + def __init__(__self__, *, + id: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None): + """ + :param _builtins.str id: Explicit OCI subnet OCID. Example: 'ocid1.subnet.oc1..aaaaaaaa'. + :param _builtins.str name: OCI subnet display name filter. Example: 'node-subnet'. + """ + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + """ + Explicit OCI subnet OCID. Example: 'ocid1.subnet.oc1..aaaaaaaa'. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + OCI subnet display name filter. Example: 'node-subnet'. + """ + return pulumi.get(self, "name") + + +@pulumi.output_type +class OCIVolumeAttributesArgs(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "sizeInGbs": + suggest = "size_in_gbs" + elif key == "vpusPerGb": + suggest = "vpus_per_gb" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in OCIVolumeAttributesArgs. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + OCIVolumeAttributesArgs.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + OCIVolumeAttributesArgs.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + size_in_gbs: Optional[_builtins.int] = None, + vpus_per_gb: Optional[_builtins.int] = None): + """ + :param _builtins.int size_in_gbs: Block volume size in GB. Example: 50. + :param _builtins.int vpus_per_gb: Block volume performance units per GB. Example: 10. + """ + if size_in_gbs is not None: + pulumi.set(__self__, "size_in_gbs", size_in_gbs) + if vpus_per_gb is not None: + pulumi.set(__self__, "vpus_per_gb", vpus_per_gb) + + @_builtins.property + @pulumi.getter(name="sizeInGbs") + def size_in_gbs(self) -> Optional[_builtins.int]: + """ + Block volume size in GB. Example: 50. + """ + return pulumi.get(self, "size_in_gbs") + + @_builtins.property + @pulumi.getter(name="vpusPerGb") + def vpus_per_gb(self) -> Optional[_builtins.int]: + """ + Block volume performance units per GB. Example: 10. + """ + return pulumi.get(self, "vpus_per_gb") @pulumi.output_type diff --git a/sdk/python/pulumi_devzero/resources/workload_policy.py b/sdk/python/pulumi_devzero/resources/workload_policy.py index 839ff38..b1a3f84 100644 --- a/sdk/python/pulumi_devzero/resources/workload_policy.py +++ b/sdk/python/pulumi_devzero/resources/workload_policy.py @@ -35,6 +35,7 @@ def __init__(__self__, *, description: Optional[pulumi.Input[_builtins.str]] = None, detection_triggers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, drift_delta_percent: Optional[pulumi.Input[_builtins.float]] = None, + emergency_response: Optional[pulumi.Input['EmergencyResponseConfigArgsArgs']] = None, enable_in_place_vertical_scaling: Optional[pulumi.Input[_builtins.bool]] = None, enable_pmax_protection: Optional[pulumi.Input[_builtins.bool]] = None, gpu_vertical_scaling: Optional[pulumi.Input['VerticalScalingArgsArgs']] = None, @@ -76,6 +77,7 @@ def __init__(__self__, *, :param pulumi.Input[_builtins.str] description: Free-form description of the policy. Example: 'VPA policy for production workloads'. :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] detection_triggers: Events that trigger a new recommendation. Valid values: 'pod_creation', 'pod_update', 'pod_reschedule'. Example: ["pod_creation", "pod_reschedule"]. :param pulumi.Input[_builtins.float] drift_delta_percent: Percentage change from the baseline recommendation that triggers a VPA refresh. Example: 20.0. + :param pulumi.Input['EmergencyResponseConfigArgsArgs'] emergency_response: Emergency response configuration for OOM and CPU throttle events. :param pulumi.Input[_builtins.bool] enable_pmax_protection: Raise requests to cover observed peak usage when the peak/recommendation ratio exceeds pmaxRatioThreshold. Default: false. :param pulumi.Input['VerticalScalingArgsArgs'] gpu_vertical_scaling: Vertical scaling configuration for GPU cores. Uses the same fields as cpuVerticalScaling; units are GPU cores (millicores). :param pulumi.Input['VerticalScalingArgsArgs'] gpu_vram_vertical_scaling: Vertical scaling configuration for GPU VRAM. Uses the same fields as cpuVerticalScaling; units are bytes. @@ -119,6 +121,8 @@ def __init__(__self__, *, pulumi.set(__self__, "detection_triggers", detection_triggers) if drift_delta_percent is not None: pulumi.set(__self__, "drift_delta_percent", drift_delta_percent) + if emergency_response is not None: + pulumi.set(__self__, "emergency_response", emergency_response) if enable_in_place_vertical_scaling is not None: pulumi.set(__self__, "enable_in_place_vertical_scaling", enable_in_place_vertical_scaling) if enable_pmax_protection is not None: @@ -340,6 +344,18 @@ def drift_delta_percent(self) -> Optional[pulumi.Input[_builtins.float]]: def drift_delta_percent(self, value: Optional[pulumi.Input[_builtins.float]]): pulumi.set(self, "drift_delta_percent", value) + @_builtins.property + @pulumi.getter(name="emergencyResponse") + def emergency_response(self) -> Optional[pulumi.Input['EmergencyResponseConfigArgsArgs']]: + """ + Emergency response configuration for OOM and CPU throttle events. + """ + return pulumi.get(self, "emergency_response") + + @emergency_response.setter + def emergency_response(self, value: Optional[pulumi.Input['EmergencyResponseConfigArgsArgs']]): + pulumi.set(self, "emergency_response", value) + @_builtins.property @pulumi.getter(name="enableInPlaceVerticalScaling") def enable_in_place_vertical_scaling(self) -> Optional[pulumi.Input[_builtins.bool]]: @@ -669,6 +685,7 @@ def __init__(__self__, description: Optional[pulumi.Input[_builtins.str]] = None, detection_triggers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, drift_delta_percent: Optional[pulumi.Input[_builtins.float]] = None, + emergency_response: Optional[pulumi.Input[Union['EmergencyResponseConfigArgsArgs', 'EmergencyResponseConfigArgsArgsDict']]] = None, enable_in_place_vertical_scaling: Optional[pulumi.Input[_builtins.bool]] = None, enable_pmax_protection: Optional[pulumi.Input[_builtins.bool]] = None, gpu_vertical_scaling: Optional[pulumi.Input[Union['VerticalScalingArgsArgs', 'VerticalScalingArgsArgsDict']]] = None, @@ -713,6 +730,7 @@ def __init__(__self__, :param pulumi.Input[_builtins.str] description: Free-form description of the policy. Example: 'VPA policy for production workloads'. :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] detection_triggers: Events that trigger a new recommendation. Valid values: 'pod_creation', 'pod_update', 'pod_reschedule'. Example: ["pod_creation", "pod_reschedule"]. :param pulumi.Input[_builtins.float] drift_delta_percent: Percentage change from the baseline recommendation that triggers a VPA refresh. Example: 20.0. + :param pulumi.Input[Union['EmergencyResponseConfigArgsArgs', 'EmergencyResponseConfigArgsArgsDict']] emergency_response: Emergency response configuration for OOM and CPU throttle events. :param pulumi.Input[_builtins.bool] enable_pmax_protection: Raise requests to cover observed peak usage when the peak/recommendation ratio exceeds pmaxRatioThreshold. Default: false. :param pulumi.Input[Union['VerticalScalingArgsArgs', 'VerticalScalingArgsArgsDict']] gpu_vertical_scaling: Vertical scaling configuration for GPU cores. Uses the same fields as cpuVerticalScaling; units are GPU cores (millicores). :param pulumi.Input[Union['VerticalScalingArgsArgs', 'VerticalScalingArgsArgsDict']] gpu_vram_vertical_scaling: Vertical scaling configuration for GPU VRAM. Uses the same fields as cpuVerticalScaling; units are bytes. @@ -765,6 +783,7 @@ def _internal_init(__self__, description: Optional[pulumi.Input[_builtins.str]] = None, detection_triggers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, drift_delta_percent: Optional[pulumi.Input[_builtins.float]] = None, + emergency_response: Optional[pulumi.Input[Union['EmergencyResponseConfigArgsArgs', 'EmergencyResponseConfigArgsArgsDict']]] = None, enable_in_place_vertical_scaling: Optional[pulumi.Input[_builtins.bool]] = None, enable_pmax_protection: Optional[pulumi.Input[_builtins.bool]] = None, gpu_vertical_scaling: Optional[pulumi.Input[Union['VerticalScalingArgsArgs', 'VerticalScalingArgsArgsDict']]] = None, @@ -820,6 +839,7 @@ def _internal_init(__self__, __props__.__dict__["description"] = description __props__.__dict__["detection_triggers"] = detection_triggers __props__.__dict__["drift_delta_percent"] = drift_delta_percent + __props__.__dict__["emergency_response"] = emergency_response __props__.__dict__["enable_in_place_vertical_scaling"] = enable_in_place_vertical_scaling __props__.__dict__["enable_pmax_protection"] = enable_pmax_protection __props__.__dict__["gpu_vertical_scaling"] = gpu_vertical_scaling @@ -898,6 +918,7 @@ def get(resource_name: str, __props__.__dict__["description"] = None __props__.__dict__["detection_triggers"] = None __props__.__dict__["drift_delta_percent"] = None + __props__.__dict__["emergency_response"] = None __props__.__dict__["enable_in_place_vertical_scaling"] = None __props__.__dict__["enable_pmax_protection"] = None __props__.__dict__["gpu_vertical_scaling"] = None @@ -1017,6 +1038,14 @@ def drift_delta_percent(self) -> pulumi.Output[Optional[_builtins.float]]: """ return pulumi.get(self, "drift_delta_percent") + @_builtins.property + @pulumi.getter(name="emergencyResponse") + def emergency_response(self) -> pulumi.Output[Optional['outputs.EmergencyResponseConfigArgs']]: + """ + Emergency response configuration for OOM and CPU throttle events. + """ + return pulumi.get(self, "emergency_response") + @_builtins.property @pulumi.getter(name="enableInPlaceVerticalScaling") def enable_in_place_vertical_scaling(self) -> pulumi.Output[Optional[_builtins.bool]]: diff --git a/sdk/python/pulumi_devzero/resources/workload_rule.py b/sdk/python/pulumi_devzero/resources/workload_rule.py index d9a60c1..b7430fa 100644 --- a/sdk/python/pulumi_devzero/resources/workload_rule.py +++ b/sdk/python/pulumi_devzero/resources/workload_rule.py @@ -26,6 +26,7 @@ def __init__(__self__, *, name: pulumi.Input[_builtins.str], namespace: pulumi.Input[_builtins.str], action_triggers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + allow_in_place_memory_limit_decrease: Optional[pulumi.Input[_builtins.bool]] = None, auto_generate: Optional[pulumi.Input[_builtins.bool]] = None, containers: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerResourceRuleConfigArgsArgs']]]] = None, cooldown_minutes: Optional[pulumi.Input[_builtins.int]] = None, @@ -37,6 +38,9 @@ def __init__(__self__, *, emergency_response: Optional[pulumi.Input['EmergencyResponseConfigArgsArgs']] = None, gpu_rule: Optional[pulumi.Input['ResourceRuleConfigArgsArgs']] = None, hpa_rule: Optional[pulumi.Input['HPARuleConfigArgsArgs']] = None, + jvm_cpu_startup_floor_millicores: Optional[pulumi.Input[_builtins.int]] = None, + jvm_heap_rule: Optional[pulumi.Input['JvmHeapRuleConfigArgsArgs']] = None, + keda_scaled_object: Optional[pulumi.Input['KedaScaledObjectArgsArgs']] = None, live_migration_enabled: Optional[pulumi.Input[_builtins.bool]] = None, lookback_period_seconds: Optional[pulumi.Input[_builtins.int]] = None, memory_rule: Optional[pulumi.Input['ResourceRuleConfigArgsArgs']] = None, @@ -51,6 +55,7 @@ def __init__(__self__, *, :param pulumi.Input[_builtins.str] name: Name of the Kubernetes workload. Example: 'my-api'. :param pulumi.Input[_builtins.str] namespace: Kubernetes namespace of the workload. Example: 'production'. :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] action_triggers: When to apply recommendations. Valid values: 'on_detection', 'on_schedule'. Example: ["on_detection"]. + :param pulumi.Input[_builtins.bool] allow_in_place_memory_limit_decrease: Allow in-place vertical scaling to decrease the memory limit (normally only requests shrink; limits only grow). Example: false. :param pulumi.Input[_builtins.bool] auto_generate: When true the engine generates all rule fields automatically; manual field overrides are ignored. Example: false. :param pulumi.Input[Sequence[pulumi.Input['ContainerResourceRuleConfigArgsArgs']]] containers: Per-container resource rule configurations. When empty, workload-level rules apply to all containers. :param pulumi.Input[_builtins.int] cooldown_minutes: Minimum minutes between consecutive recommendation applications. Example: 60. @@ -61,6 +66,9 @@ def __init__(__self__, *, :param pulumi.Input['EmergencyResponseConfigArgsArgs'] emergency_response: Emergency response configuration for OOM and CPU throttle events. :param pulumi.Input['ResourceRuleConfigArgsArgs'] gpu_rule: GPU vertical scaling rule configuration. :param pulumi.Input['HPARuleConfigArgsArgs'] hpa_rule: Horizontal (replica) scaling rule configuration. + :param pulumi.Input[_builtins.int] jvm_cpu_startup_floor_millicores: Minimum CPU request in millicores during JVM startup, to avoid slow JIT warmup on undersized CPU. Example: 500. + :param pulumi.Input['JvmHeapRuleConfigArgsArgs'] jvm_heap_rule: JVM heap sizing overrides applied to detected Java containers. + :param pulumi.Input['KedaScaledObjectArgsArgs'] keda_scaled_object: KEDA ScaledObject configuration managed alongside this workload. :param pulumi.Input[_builtins.bool] live_migration_enabled: Allow live pod migration when applying recommendations. Example: false. :param pulumi.Input['ResourceRuleConfigArgsArgs'] memory_rule: Memory vertical scaling rule configuration. :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] scheduler_plugins: Kubernetes scheduler plugins to activate. Example: ["binpacking"]. @@ -73,6 +81,8 @@ def __init__(__self__, *, pulumi.set(__self__, "namespace", namespace) if action_triggers is not None: pulumi.set(__self__, "action_triggers", action_triggers) + if allow_in_place_memory_limit_decrease is not None: + pulumi.set(__self__, "allow_in_place_memory_limit_decrease", allow_in_place_memory_limit_decrease) if auto_generate is not None: pulumi.set(__self__, "auto_generate", auto_generate) if containers is not None: @@ -95,6 +105,12 @@ def __init__(__self__, *, pulumi.set(__self__, "gpu_rule", gpu_rule) if hpa_rule is not None: pulumi.set(__self__, "hpa_rule", hpa_rule) + if jvm_cpu_startup_floor_millicores is not None: + pulumi.set(__self__, "jvm_cpu_startup_floor_millicores", jvm_cpu_startup_floor_millicores) + if jvm_heap_rule is not None: + pulumi.set(__self__, "jvm_heap_rule", jvm_heap_rule) + if keda_scaled_object is not None: + pulumi.set(__self__, "keda_scaled_object", keda_scaled_object) if live_migration_enabled is not None: pulumi.set(__self__, "live_migration_enabled", live_migration_enabled) if lookback_period_seconds is not None: @@ -168,6 +184,18 @@ def action_triggers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builti def action_triggers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): pulumi.set(self, "action_triggers", value) + @_builtins.property + @pulumi.getter(name="allowInPlaceMemoryLimitDecrease") + def allow_in_place_memory_limit_decrease(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Allow in-place vertical scaling to decrease the memory limit (normally only requests shrink; limits only grow). Example: false. + """ + return pulumi.get(self, "allow_in_place_memory_limit_decrease") + + @allow_in_place_memory_limit_decrease.setter + def allow_in_place_memory_limit_decrease(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "allow_in_place_memory_limit_decrease", value) + @_builtins.property @pulumi.getter(name="autoGenerate") def auto_generate(self) -> Optional[pulumi.Input[_builtins.bool]]: @@ -297,6 +325,42 @@ def hpa_rule(self) -> Optional[pulumi.Input['HPARuleConfigArgsArgs']]: def hpa_rule(self, value: Optional[pulumi.Input['HPARuleConfigArgsArgs']]): pulumi.set(self, "hpa_rule", value) + @_builtins.property + @pulumi.getter(name="jvmCpuStartupFloorMillicores") + def jvm_cpu_startup_floor_millicores(self) -> Optional[pulumi.Input[_builtins.int]]: + """ + Minimum CPU request in millicores during JVM startup, to avoid slow JIT warmup on undersized CPU. Example: 500. + """ + return pulumi.get(self, "jvm_cpu_startup_floor_millicores") + + @jvm_cpu_startup_floor_millicores.setter + def jvm_cpu_startup_floor_millicores(self, value: Optional[pulumi.Input[_builtins.int]]): + pulumi.set(self, "jvm_cpu_startup_floor_millicores", value) + + @_builtins.property + @pulumi.getter(name="jvmHeapRule") + def jvm_heap_rule(self) -> Optional[pulumi.Input['JvmHeapRuleConfigArgsArgs']]: + """ + JVM heap sizing overrides applied to detected Java containers. + """ + return pulumi.get(self, "jvm_heap_rule") + + @jvm_heap_rule.setter + def jvm_heap_rule(self, value: Optional[pulumi.Input['JvmHeapRuleConfigArgsArgs']]): + pulumi.set(self, "jvm_heap_rule", value) + + @_builtins.property + @pulumi.getter(name="kedaScaledObject") + def keda_scaled_object(self) -> Optional[pulumi.Input['KedaScaledObjectArgsArgs']]: + """ + KEDA ScaledObject configuration managed alongside this workload. + """ + return pulumi.get(self, "keda_scaled_object") + + @keda_scaled_object.setter + def keda_scaled_object(self, value: Optional[pulumi.Input['KedaScaledObjectArgsArgs']]): + pulumi.set(self, "keda_scaled_object", value) + @_builtins.property @pulumi.getter(name="liveMigrationEnabled") def live_migration_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: @@ -374,6 +438,7 @@ def __init__(__self__, resource_name: str, opts: Optional[pulumi.ResourceOptions] = None, action_triggers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + allow_in_place_memory_limit_decrease: Optional[pulumi.Input[_builtins.bool]] = None, auto_generate: Optional[pulumi.Input[_builtins.bool]] = None, cluster_id: Optional[pulumi.Input[_builtins.str]] = None, containers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerResourceRuleConfigArgsArgs', 'ContainerResourceRuleConfigArgsArgsDict']]]]] = None, @@ -386,6 +451,9 @@ def __init__(__self__, emergency_response: Optional[pulumi.Input[Union['EmergencyResponseConfigArgsArgs', 'EmergencyResponseConfigArgsArgsDict']]] = None, gpu_rule: Optional[pulumi.Input[Union['ResourceRuleConfigArgsArgs', 'ResourceRuleConfigArgsArgsDict']]] = None, hpa_rule: Optional[pulumi.Input[Union['HPARuleConfigArgsArgs', 'HPARuleConfigArgsArgsDict']]] = None, + jvm_cpu_startup_floor_millicores: Optional[pulumi.Input[_builtins.int]] = None, + jvm_heap_rule: Optional[pulumi.Input[Union['JvmHeapRuleConfigArgsArgs', 'JvmHeapRuleConfigArgsArgsDict']]] = None, + keda_scaled_object: Optional[pulumi.Input[Union['KedaScaledObjectArgsArgs', 'KedaScaledObjectArgsArgsDict']]] = None, kind: Optional[pulumi.Input[_builtins.str]] = None, live_migration_enabled: Optional[pulumi.Input[_builtins.bool]] = None, lookback_period_seconds: Optional[pulumi.Input[_builtins.int]] = None, @@ -402,6 +470,7 @@ def __init__(__self__, :param str resource_name: The name of the resource. :param pulumi.ResourceOptions opts: Options for the resource. :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] action_triggers: When to apply recommendations. Valid values: 'on_detection', 'on_schedule'. Example: ["on_detection"]. + :param pulumi.Input[_builtins.bool] allow_in_place_memory_limit_decrease: Allow in-place vertical scaling to decrease the memory limit (normally only requests shrink; limits only grow). Example: false. :param pulumi.Input[_builtins.bool] auto_generate: When true the engine generates all rule fields automatically; manual field overrides are ignored. Example: false. :param pulumi.Input[_builtins.str] cluster_id: ID of the cluster this rule targets. Example: 'cluster-abc123'. :param pulumi.Input[Sequence[pulumi.Input[Union['ContainerResourceRuleConfigArgsArgs', 'ContainerResourceRuleConfigArgsArgsDict']]]] containers: Per-container resource rule configurations. When empty, workload-level rules apply to all containers. @@ -413,6 +482,9 @@ def __init__(__self__, :param pulumi.Input[Union['EmergencyResponseConfigArgsArgs', 'EmergencyResponseConfigArgsArgsDict']] emergency_response: Emergency response configuration for OOM and CPU throttle events. :param pulumi.Input[Union['ResourceRuleConfigArgsArgs', 'ResourceRuleConfigArgsArgsDict']] gpu_rule: GPU vertical scaling rule configuration. :param pulumi.Input[Union['HPARuleConfigArgsArgs', 'HPARuleConfigArgsArgsDict']] hpa_rule: Horizontal (replica) scaling rule configuration. + :param pulumi.Input[_builtins.int] jvm_cpu_startup_floor_millicores: Minimum CPU request in millicores during JVM startup, to avoid slow JIT warmup on undersized CPU. Example: 500. + :param pulumi.Input[Union['JvmHeapRuleConfigArgsArgs', 'JvmHeapRuleConfigArgsArgsDict']] jvm_heap_rule: JVM heap sizing overrides applied to detected Java containers. + :param pulumi.Input[Union['KedaScaledObjectArgsArgs', 'KedaScaledObjectArgsArgsDict']] keda_scaled_object: KEDA ScaledObject configuration managed alongside this workload. :param pulumi.Input[_builtins.str] kind: Kubernetes workload kind. One of: 'Deployment', 'StatefulSet', 'DaemonSet', 'CronJob', 'Job'. Example: 'Deployment'. :param pulumi.Input[_builtins.bool] live_migration_enabled: Allow live pod migration when applying recommendations. Example: false. :param pulumi.Input[Union['ResourceRuleConfigArgsArgs', 'ResourceRuleConfigArgsArgsDict']] memory_rule: Memory vertical scaling rule configuration. @@ -447,6 +519,7 @@ def _internal_init(__self__, resource_name: str, opts: Optional[pulumi.ResourceOptions] = None, action_triggers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + allow_in_place_memory_limit_decrease: Optional[pulumi.Input[_builtins.bool]] = None, auto_generate: Optional[pulumi.Input[_builtins.bool]] = None, cluster_id: Optional[pulumi.Input[_builtins.str]] = None, containers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerResourceRuleConfigArgsArgs', 'ContainerResourceRuleConfigArgsArgsDict']]]]] = None, @@ -459,6 +532,9 @@ def _internal_init(__self__, emergency_response: Optional[pulumi.Input[Union['EmergencyResponseConfigArgsArgs', 'EmergencyResponseConfigArgsArgsDict']]] = None, gpu_rule: Optional[pulumi.Input[Union['ResourceRuleConfigArgsArgs', 'ResourceRuleConfigArgsArgsDict']]] = None, hpa_rule: Optional[pulumi.Input[Union['HPARuleConfigArgsArgs', 'HPARuleConfigArgsArgsDict']]] = None, + jvm_cpu_startup_floor_millicores: Optional[pulumi.Input[_builtins.int]] = None, + jvm_heap_rule: Optional[pulumi.Input[Union['JvmHeapRuleConfigArgsArgs', 'JvmHeapRuleConfigArgsArgsDict']]] = None, + keda_scaled_object: Optional[pulumi.Input[Union['KedaScaledObjectArgsArgs', 'KedaScaledObjectArgsArgsDict']]] = None, kind: Optional[pulumi.Input[_builtins.str]] = None, live_migration_enabled: Optional[pulumi.Input[_builtins.bool]] = None, lookback_period_seconds: Optional[pulumi.Input[_builtins.int]] = None, @@ -478,6 +554,7 @@ def _internal_init(__self__, __props__ = WorkloadRuleArgs.__new__(WorkloadRuleArgs) __props__.__dict__["action_triggers"] = action_triggers + __props__.__dict__["allow_in_place_memory_limit_decrease"] = allow_in_place_memory_limit_decrease __props__.__dict__["auto_generate"] = auto_generate if cluster_id is None and not opts.urn: raise TypeError("Missing required property 'cluster_id'") @@ -492,6 +569,9 @@ def _internal_init(__self__, __props__.__dict__["emergency_response"] = emergency_response __props__.__dict__["gpu_rule"] = gpu_rule __props__.__dict__["hpa_rule"] = hpa_rule + __props__.__dict__["jvm_cpu_startup_floor_millicores"] = jvm_cpu_startup_floor_millicores + __props__.__dict__["jvm_heap_rule"] = jvm_heap_rule + __props__.__dict__["keda_scaled_object"] = keda_scaled_object if kind is None and not opts.urn: raise TypeError("Missing required property 'kind'") __props__.__dict__["kind"] = kind @@ -530,6 +610,7 @@ def get(resource_name: str, __props__ = WorkloadRuleArgs.__new__(WorkloadRuleArgs) __props__.__dict__["action_triggers"] = None + __props__.__dict__["allow_in_place_memory_limit_decrease"] = None __props__.__dict__["auto_generate"] = None __props__.__dict__["cluster_id"] = None __props__.__dict__["containers"] = None @@ -542,6 +623,9 @@ def get(resource_name: str, __props__.__dict__["emergency_response"] = None __props__.__dict__["gpu_rule"] = None __props__.__dict__["hpa_rule"] = None + __props__.__dict__["jvm_cpu_startup_floor_millicores"] = None + __props__.__dict__["jvm_heap_rule"] = None + __props__.__dict__["keda_scaled_object"] = None __props__.__dict__["kind"] = None __props__.__dict__["live_migration_enabled"] = None __props__.__dict__["lookback_period_seconds"] = None @@ -561,6 +645,14 @@ def action_triggers(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]: """ return pulumi.get(self, "action_triggers") + @_builtins.property + @pulumi.getter(name="allowInPlaceMemoryLimitDecrease") + def allow_in_place_memory_limit_decrease(self) -> pulumi.Output[Optional[_builtins.bool]]: + """ + Allow in-place vertical scaling to decrease the memory limit (normally only requests shrink; limits only grow). Example: false. + """ + return pulumi.get(self, "allow_in_place_memory_limit_decrease") + @_builtins.property @pulumi.getter(name="autoGenerate") def auto_generate(self) -> pulumi.Output[Optional[_builtins.bool]]: @@ -654,6 +746,30 @@ def hpa_rule(self) -> pulumi.Output[Optional['outputs.HPARuleConfigArgs']]: """ return pulumi.get(self, "hpa_rule") + @_builtins.property + @pulumi.getter(name="jvmCpuStartupFloorMillicores") + def jvm_cpu_startup_floor_millicores(self) -> pulumi.Output[Optional[_builtins.int]]: + """ + Minimum CPU request in millicores during JVM startup, to avoid slow JIT warmup on undersized CPU. Example: 500. + """ + return pulumi.get(self, "jvm_cpu_startup_floor_millicores") + + @_builtins.property + @pulumi.getter(name="jvmHeapRule") + def jvm_heap_rule(self) -> pulumi.Output[Optional['outputs.JvmHeapRuleConfigArgs']]: + """ + JVM heap sizing overrides applied to detected Java containers. + """ + return pulumi.get(self, "jvm_heap_rule") + + @_builtins.property + @pulumi.getter(name="kedaScaledObject") + def keda_scaled_object(self) -> pulumi.Output[Optional['outputs.KedaScaledObjectArgs']]: + """ + KEDA ScaledObject configuration managed alongside this workload. + """ + return pulumi.get(self, "keda_scaled_object") + @_builtins.property @pulumi.getter def kind(self) -> pulumi.Output[_builtins.str]: From e236502f9cb14c24323854d767240c4f8fd12a52 Mon Sep 17 00:00:00 2001 From: Rupam-It Date: Fri, 28 Aug 2026 00:19:31 +0530 Subject: [PATCH 6/6] read me is added Signed-off-by: Rupam-It --- README.md | 189 +++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 186 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 5cd9369..e0e444d 100644 --- a/README.md +++ b/README.md @@ -10,7 +10,7 @@ The official [Pulumi](https://www.pulumi.com/) provider for [DevZero](https://de | `WorkloadPolicy` | Configure vertical/horizontal scaling policies for workloads | | `WorkloadPolicyTarget` | Apply a workload policy to one or more clusters with filters | | `WorkloadRule` | Pin explicit resource rules to a specific workload (MPA v3) | -| `NodePolicy` | Configure node provisioning and pooling (AWS / Azure) | +| `NodePolicy` | Configure node provisioning and pooling (AWS / Azure / GCP / OCI) | | `NodePolicyTarget` | Apply a node policy to one or more clusters | ## Prerequisites @@ -735,6 +735,7 @@ ctx.Export("existingClusterId", pulumi.String(existing.ClusterId)) | `gpuVerticalScaling` | `VerticalScalingArgs` | GPU core vertical scaling configuration (units: GPU millicores) | | `gpuVramVerticalScaling` | `VerticalScalingArgs` | GPU VRAM vertical scaling configuration (units: bytes) | | `horizontalScaling` | `HorizontalScalingArgs` | Horizontal (replica) scaling configuration | +| `emergencyResponse` | `EmergencyResponseConfigArgs` | Immediate OOM / CPU-throttling reaction configuration (see [EmergencyResponseConfigArgs](#emergencyresponseconfigargs)) | | `actionTriggers` | string[] | When to apply recommendations: `on_detection` \| `on_schedule`. Both can be used together. | | `cronSchedule` | string | 5-field UTC cron expression for scheduled application. Required when `actionTriggers` includes `on_schedule`. Example: `0 2 * * *` | | `detectionTriggers` | string[] | Events that trigger a recommendation: `pod_creation` \| `pod_update` \| `pod_reschedule` | @@ -753,7 +754,7 @@ ctx.Export("existingClusterId", pulumi.String(existing.ClusterId)) | `minVpaWindowDataPoints` | int | Minimum data points in VPA analysis window. Default: `30` | | `cooldownMinutes` | int | Minutes to wait between applying recommendations. Default: `300` (5 h) | -Python uses snake_case for all fields (e.g. `cpu_vertical_scaling`, `action_triggers`, `cron_schedule`, `detection_triggers`, `enable_pmax_protection`, `loopback_period_seconds`, `min_data_points`, `min_change_percent`, `cooldown_minutes`). Go uses PascalCase equivalents. +Python uses snake_case for all fields (e.g. `cpu_vertical_scaling`, `emergency_response`, `action_triggers`, `cron_schedule`, `detection_triggers`, `enable_pmax_protection`, `loopback_period_seconds`, `min_data_points`, `min_change_percent`, `cooldown_minutes`). Go uses PascalCase equivalents. ### VerticalScalingArgs @@ -840,6 +841,7 @@ Python: `policy_id`, `cluster_ids`, `kind_filter`, `workload_names`, `node_group | `architectures` | `LabelSelectorArgs` | CPU architectures (e.g. `amd64`, `arm64`) | | `operatingSystems` | `LabelSelectorArgs` | OS filter (e.g. `linux`, `windows`) | | `labels` | map[string]string | Labels applied to provisioned nodes | +| `instanceShapes` | `LabelSelectorArgs` | GCP-only: filter by standard/highcpu/highmem custom shape token. Example: `{in: ["standard", "highmem"]}` | | `taints` | `TaintArgs[]` | Taints applied to provisioned nodes | | `disruption` | `DisruptionPolicyArgs` | Node disruption and consolidation settings | | `limits` | `ResourceLimitsArgs` | Max total CPU/memory this policy may provision | @@ -847,9 +849,14 @@ Python: `policy_id`, `cluster_ids`, `kind_filter`, `workload_names`, `node_group | `nodeClassName` | string | Override name for the generated dzkarp NodeClass CR | | `aws` | `AWSNodeClassSpecArgs` | AWS-specific configuration (AMI, subnets, IAM role, EBS, etc.) | | `azure` | `AzureNodeClassSpecArgs` | Azure-specific configuration (subnet, image family, disk, etc.) | +| `gcp` | `GCPNodeClassSpecArgs` | GCP-specific GCENodeClass configuration (service account, images, disks, etc.) | +| `oci` | `OCINodeClassSpecArgs` | OCI-specific NodeClass configuration (VCN, subnets, images, block volumes, etc.) | | `raw` | `RawKarpenterSpecArgs[]` | Raw Karpenter NodePool/NodeClass YAML (escape hatch) | +| `instanceShapesTip` | string | UI tooltip text shown alongside the `instanceShapes` selector | +| `startupTaintsTip` | string | UI tooltip text shown alongside `startupTaints` | +| `instanceLocalNvmeTip` | string | UI tooltip text shown alongside the instance-local-NVMe selector | -Python uses snake_case (e.g. `capacity_types`, `instance_categories`, `instance_families`, `instance_cpus`, `instance_sizes`, `instance_types`, `operating_systems`, `node_pool_name`, `node_class_name`). Go uses PascalCase equivalents. +Python uses snake_case (e.g. `capacity_types`, `instance_categories`, `instance_families`, `instance_cpus`, `instance_sizes`, `instance_types`, `instance_shapes`, `operating_systems`, `node_pool_name`, `node_class_name`, `instance_shapes_tip`, `startup_taints_tip`, `instance_local_nvme_tip`). Go uses PascalCase equivalents. ### DisruptionPolicyArgs @@ -908,6 +915,102 @@ Python: `ami_family`, `instance_profile`, `subnet_selector_terms`, `security_gro Python: `vnet_subnet_id`, `image_family`, `os_disk_size_gb`, `fips_mode`, `max_pods`. Go uses PascalCase equivalents. +### GCPNodeClassSpecArgs + +| Field | Type | Description | +|---|---|---| +| `serviceAccount` | string | GCP service account email attached to provisioned nodes | +| `imageFamily` | string | GCE image family. Example: `cos` | +| `imageSelectorTerms` | `GCPImageSelectorTermArgs[]` | Image selectors (by alias or ID) | +| `disks` | `GCPDiskArgs[]` | Boot and secondary disk configuration | +| `kubelet` | `KubeletConfigurationArgs` | Kubelet overrides (maxPods, eviction thresholds, etc.) | +| `labels` | map[string]string | GCP labels applied to provisioned nodes | +| `metadata` | map[string]string | GCE instance metadata key/value pairs | +| `networkTags` | string[] | GCP network tags applied to provisioned instances | + +Python: `service_account`, `image_family`, `image_selector_terms`, `network_tags`. Go uses PascalCase equivalents. + +#### GCPImageSelectorTermArgs + +| Field | Type | Description | +|---|---|---| +| `alias` | string | Image alias. Example: `cos@latest` | +| `id` | string | Explicit GCE image ID | + +#### GCPDiskArgs + +| Field | Type | Description | +|---|---|---| +| `boot` | bool | Whether this disk is the boot disk. Example: `true` | +| `category` | string | GCP disk type. Example: `pd-ssd` | +| `sizeGib` | int | Disk size in GiB. Example: `100` | +| `secondaryBootImage` | string | Secondary boot image used for container-image fast boot | +| `secondaryBootMode` | string | Secondary boot mode. Example: `CONTAINER_IMAGE_CACHE` | + +Python: `size_gib`, `secondary_boot_image`, `secondary_boot_mode`. Go uses PascalCase equivalents. + +### OCINodeClassSpecArgs + +| Field | Type | Description | +|---|---|---| +| `vcnId` | string | OCI VCN OCID nodes are provisioned into | +| `imageFamily` | string | OCI image family. Example: `Oracle-Linux-8` | +| `imageSelector` | `OCIImageSelectorTermArgs[]` | Image selectors (by name, ID, or compartment) | +| `subnetSelector` | `OCISubnetSelectorTermArgs[]` | Subnet selectors (by name or ID) | +| `securityGroupSelector` | `OCISecurityGroupSelectorTermArgs[]` | Network security group selectors | +| `bootConfig` | `OCIBootConfigArgs` | Boot volume size and performance configuration | +| `blockDevices` | `OCIVolumeAttributesArgs[]` | Additional block volume configuration | +| `launchOptions` | `OCILaunchOptionsArgs` | Instance launch options (firmware, network type, etc.) | +| `agentList` | string[] | OCI Compute Instance Agent plugins to enable. Example: `Compute Instance Monitoring` | +| `freeFormTags` | map[string]string | OCI free-form tags applied to provisioned resources | +| `tags` | map[string]string | Defined tags applied to provisioned resources | +| `metaData` | map[string]string | Instance metadata key/value pairs | +| `userData` | string | Custom cloud-init user data | +| `preInstallScript` | string | Script executed before dzkarp bootstrap runs | + +Python: `vcn_id`, `image_family`, `image_selector`, `subnet_selector`, `security_group_selector`, `boot_config`, `block_devices`, `launch_options`, `agent_list`, `free_form_tags`, `meta_data`, `user_data`, `pre_install_script`. Go uses PascalCase equivalents. + +#### OCIImageSelectorTermArgs + +| Field | Type | Description | +|---|---|---| +| `name` | string | Image display name | +| `id` | string | Explicit image OCID | +| `compartmentId` | string | Compartment OCID to search for the image in | + +#### OCISubnetSelectorTermArgs / OCISecurityGroupSelectorTermArgs + +| Field | Type | Description | +|---|---|---| +| `name` | string | Resource display name | +| `id` | string | Explicit OCID | + +#### OCIBootConfigArgs + +| Field | Type | Description | +|---|---|---| +| `bootVolumeSizeInGbs` | int | Boot volume size in GB | +| `bootVolumeVpusPerGb` | int | Boot volume performance units per GB | + +#### OCIVolumeAttributesArgs + +| Field | Type | Description | +|---|---|---| +| `sizeInGbs` | int | Block volume size in GB | +| `vpusPerGb` | int | Block volume performance units per GB | + +#### OCILaunchOptionsArgs + +| Field | Type | Description | +|---|---|---| +| `firmware` | string | Firmware type. Example: `UEFI_64` | +| `bootVolumeType` | string | Boot volume attachment type. Example: `PARAVIRTUALIZED` | +| `networkType` | string | Network attachment type. Example: `PARAVIRTUALIZED` | +| `remoteDataVolumeType` | string | Remote data volume attachment type | +| `isConsistentVolumeNamingEnabled` | bool | Enable consistent device naming for volumes | + +Python: `boot_volume_type`, `network_type`, `remote_data_volume_type`, `is_consistent_volume_naming_enabled`. Go uses PascalCase equivalents. + ### RawKarpenterSpecArgs Use this as an escape hatch when the structured fields don't cover your use case and you need full control over the Karpenter NodePool/NodeClass resources. @@ -1171,8 +1274,14 @@ ctx.Export("ruleId", rule.ID()) | `defragmentationSchedule` | string | Cron expression for node defragmentation | | `liveMigrationEnabled` | bool | Allow live pod migration when applying recommendations without restart | | `useInPlaceVerticalScaling` | bool | Use in-place pod vertical scaling instead of pod restarts | +| `allowInPlaceMemoryLimitDecrease` | bool | Allow in-place scaling to decrease the memory limit (normally only increases are applied in-place) | +| `jvmHeapRule` | `JvmHeapRuleConfigArgs` | JVM heap-aware sizing rule (see [JvmHeapRuleConfigArgs](#jvmheapruleconfigargs)) | +| `jvmCpuStartupFloorMillicores` | int | Minimum CPU (millicores) reserved during JVM startup/warmup | +| `kedaScaledObject` | `KedaScaledObjectArgs` | KEDA `ScaledObject` configuration for event-driven autoscaling (see [KedaScaledObjectArgs](#kedascaledobjectargs)) | | `containers` | `ContainerResourceRuleConfigArgs[]` | Per-container resource overrides. When empty, workload-level rules apply to all containers | +Python uses snake_case (e.g. `cluster_id`, `auto_generate`, `cpu_rule`, `hpa_rule`, `emergency_response`, `action_triggers`, `cron_schedule`, `detection_triggers`, `startup_period_seconds`, `use_in_place_vertical_scaling`, `allow_in_place_memory_limit_decrease`, `jvm_heap_rule`, `jvm_cpu_startup_floor_millicores`, `keda_scaled_object`). Go uses PascalCase equivalents. + ### ResourceRuleConfigArgs Used for `cpuRule`, `memoryRule`, and `gpuRule` at both the workload and per-container level. @@ -1424,6 +1533,80 @@ Python: `stabilization_window_seconds`, `select_policy`, `period_seconds`. Go us | `memoryRule` | `ResourceRuleConfigArgs` | Memory rule for this container | | `gpuRule` | `ResourceRuleConfigArgs` | GPU rule for this container | +### JvmHeapRuleConfigArgs + +JVM heap-aware sizing rule used by `jvmHeapRule` — sizes container memory based on observed JVM heap usage rather than raw process RSS. + +| Field | Type | Description | +|---|---|---| +| `enabled` | bool | Enable JVM heap-aware sizing for this workload | +| `minHeapBytes` | int | Minimum heap size in bytes | +| `maxHeapBytes` | int | Maximum heap size in bytes | +| `targetPercentile` | float | Percentile of observed heap usage to target. Example: `0.95` | +| `headroomMultiplier` | float | Multiplier applied on top of the target percentile for safety headroom. Example: `1.3` | +| `nonHeapOverheadPercent` | float | Additional non-heap memory overhead as a percentage. Example: `0.2` | +| `nonHeapOverheadBytes` | int | Additional non-heap memory overhead as a fixed byte amount | +| `preferContainerSupport` | bool | Prefer the JVM's container-aware ergonomics (`-XX:+UseContainerSupport`) over manual heap flags | + +Python: `min_heap_bytes`, `max_heap_bytes`, `target_percentile`, `headroom_multiplier`, `non_heap_overhead_percent`, `non_heap_overhead_bytes`, `prefer_container_support`. Go uses PascalCase equivalents. + +### KedaScaledObjectArgs + +KEDA `ScaledObject` configuration used by `kedaScaledObject` for event-driven horizontal autoscaling. + +| Field | Type | Description | +|---|---|---| +| `minReplicaCount` | int | Minimum replica count | +| `maxReplicaCount` | int | Maximum replica count | +| `idleReplicaCount` | int | Replica count to scale to when idle (must be less than `minReplicaCount`) | +| `pollingInterval` | int | Seconds between trigger metric evaluations | +| `cooldownPeriod` | int | Seconds to wait after the last active trigger before scaling back down | +| `initialCooldownPeriod` | int | Seconds after ScaledObject creation before the cooldown period starts counting | +| `triggers` | `KedaTriggerArgs[]` | Event source triggers (Prometheus, Kafka, etc.) | +| `fallback` | `KedaFallbackArgs` | Replica count to fall back to when triggers can't be evaluated | +| `advanced` | `KedaAdvancedArgs` | Advanced HPA behavior passthrough | + +Python: `min_replica_count`, `max_replica_count`, `idle_replica_count`, `polling_interval`, `cooldown_period`, `initial_cooldown_period`. Go uses PascalCase equivalents. + +#### KedaTriggerArgs + +| Field | Type | Description | +|---|---|---| +| `type` | string | **Required.** Trigger type. Example: `prometheus`, `kafka` | +| `name` | string | Trigger name | +| `metricType` | string | Metric type: `Value` \| `AverageValue` \| `Utilization` | +| `metadata` | map[string]string | Trigger-specific metadata (e.g. `serverAddress`, `query` for Prometheus) | +| `authenticationRef` | `KedaAuthenticationRefArgs` | Reference to a KEDA `TriggerAuthentication`/`ClusterTriggerAuthentication` | +| `useCachedMetrics` | bool | Use KEDA's cached metrics instead of querying the source on every poll | + +Python: `metric_type`, `authentication_ref`, `use_cached_metrics`. Go uses PascalCase equivalents. + +#### KedaFallbackArgs + +| Field | Type | Description | +|---|---|---| +| `failureThreshold` | int | **Required.** Number of consecutive trigger evaluation failures before fallback activates | +| `replicas` | int | **Required.** Replica count to use while in fallback | +| `behavior` | string | Fallback behavior. Example: `static` | + +Python: `failure_threshold`. Go uses PascalCase equivalents. + +#### KedaAdvancedArgs + +| Field | Type | Description | +|---|---|---| +| `restoreToOriginalReplicaCount` | bool | Restore the pre-KEDA replica count when the ScaledObject is deleted | +| `advancedBehaviorJson` | string | Raw JSON-encoded `HorizontalPodAutoscalerBehavior` passthrough (scale-up/down stabilization windows and policies) | + +Python: `restore_to_original_replica_count`, `advanced_behavior_json`. Go uses PascalCase equivalents. + +#### KedaAuthenticationRefArgs + +| Field | Type | Description | +|---|---|---| +| `name` | string | **Required.** Name of the `TriggerAuthentication`/`ClusterTriggerAuthentication` resource | +| `kind` | string | `TriggerAuthentication` \| `ClusterTriggerAuthentication` | + ## NodePolicyTarget — Key Fields | Field | Type | Description |