@pulumi/azure-native 1.77.0 → 1.78.0-alpha.1663142157

package/types/enums/containerservice/v20220802preview/index.d.ts

@@ -0,0 +1,520 @@
+export declare const AgentPoolMode: {
+    /**
+     * System agent pools are primarily for hosting critical system pods such as CoreDNS and metrics-server. System agent pools osType must be Linux. System agent pools VM SKU must have at least 2vCPUs and 4GB of memory.
+     */
+    readonly System: "System";
+    /**
+     * User agent pools are primarily for hosting your application pods.
+     */
+    readonly User: "User";
+};
+/**
+ * A cluster must have at least one 'System' Agent Pool at all times. For additional information on agent pool restrictions and best practices, see: https://docs.microsoft.com/azure/aks/use-system-pools
+ */
+export declare type AgentPoolMode = (typeof AgentPoolMode)[keyof typeof AgentPoolMode];
+export declare const AgentPoolType: {
+    /**
+     * Create an Agent Pool backed by a Virtual Machine Scale Set.
+     */
+    readonly VirtualMachineScaleSets: "VirtualMachineScaleSets";
+    /**
+     * Use of this is strongly discouraged.
+     */
+    readonly AvailabilitySet: "AvailabilitySet";
+};
+/**
+ * The type of Agent Pool.
+ */
+export declare type AgentPoolType = (typeof AgentPoolType)[keyof typeof AgentPoolType];
+export declare const BackendPoolType: {
+    /**
+     * The type of the managed inbound Load Balancer BackendPool. https://cloud-provider-azure.sigs.k8s.io/topics/loadbalancer/#configure-load-balancer-backend.
+     */
+    readonly NodeIPConfiguration: "NodeIPConfiguration";
+    /**
+     * The type of the managed inbound Load Balancer BackendPool. https://cloud-provider-azure.sigs.k8s.io/topics/loadbalancer/#configure-load-balancer-backend.
+     */
+    readonly NodeIP: "NodeIP";
+};
+/**
+ * The type of the managed inbound Load Balancer BackendPool.
+ */
+export declare type BackendPoolType = (typeof BackendPoolType)[keyof typeof BackendPoolType];
+export declare const Code: {
+    /**
+     * The cluster is running.
+     */
+    readonly Running: "Running";
+    /**
+     * The cluster is stopped.
+     */
+    readonly Stopped: "Stopped";
+};
+/**
+ * Tells whether the cluster is Running or Stopped
+ */
+export declare type Code = (typeof Code)[keyof typeof Code];
+export declare const ConnectionStatus: {
+    readonly Pending: "Pending";
+    readonly Approved: "Approved";
+    readonly Rejected: "Rejected";
+    readonly Disconnected: "Disconnected";
+};
+/**
+ * The private link service connection status.
+ */
+export declare type ConnectionStatus = (typeof ConnectionStatus)[keyof typeof ConnectionStatus];
+export declare const ControlledValues: {
+    /**
+     * Autoscaler will control resource requests and limits.
+     */
+    readonly RequestsAndLimits: "RequestsAndLimits";
+    /**
+     * Autoscaler will control resource requests only.
+     */
+    readonly RequestsOnly: "RequestsOnly";
+};
+/**
+ * Controls which resource value autoscaler will change. Default value is RequestsAndLimits.
+ */
+export declare type ControlledValues = (typeof ControlledValues)[keyof typeof ControlledValues];
+export declare const Expander: {
+    /**
+     * Selects the node group that will have the least idle CPU (if tied, unused memory) after scale-up. This is useful when you have different classes of nodes, for example, high CPU or high memory nodes, and only want to expand those when there are pending pods that need a lot of those resources.
+     */
+    readonly Least_waste: "least-waste";
+    /**
+     * Selects the node group that would be able to schedule the most pods when scaling up. This is useful when you are using nodeSelector to make sure certain pods land on certain nodes. Note that this won't cause the autoscaler to select bigger nodes vs. smaller, as it can add multiple smaller nodes at once.
+     */
+    readonly Most_pods: "most-pods";
+    /**
+     * Selects the node group that has the highest priority assigned by the user. It's configuration is described in more details [here](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/expander/priority/readme.md).
+     */
+    readonly Priority: "priority";
+    /**
+     * Used when you don't have a particular need for the node groups to scale differently.
+     */
+    readonly Random: "random";
+};
+/**
+ * If not specified, the default is 'random'. See [expanders](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/FAQ.md#what-are-expanders) for more information.
+ */
+export declare type Expander = (typeof Expander)[keyof typeof Expander];
+export declare const ExtendedLocationTypes: {
+    readonly EdgeZone: "EdgeZone";
+};
+/**
+ * The type of the extended location.
+ */
+export declare type ExtendedLocationTypes = (typeof ExtendedLocationTypes)[keyof typeof ExtendedLocationTypes];
+export declare const GPUInstanceProfile: {
+    readonly MIG1g: "MIG1g";
+    readonly MIG2g: "MIG2g";
+    readonly MIG3g: "MIG3g";
+    readonly MIG4g: "MIG4g";
+    readonly MIG7g: "MIG7g";
+};
+/**
+ * GPUInstanceProfile to be used to specify GPU MIG instance profile for supported GPU VM SKU.
+ */
+export declare type GPUInstanceProfile = (typeof GPUInstanceProfile)[keyof typeof GPUInstanceProfile];
+export declare const IpFamily: {
+    readonly IPv4: "IPv4";
+    readonly IPv6: "IPv6";
+};
+/**
+ * The IP version to use for cluster networking and IP assignment.
+ */
+export declare type IpFamily = (typeof IpFamily)[keyof typeof IpFamily];
+export declare const IpvsScheduler: {
+    /**
+     * Round Robin
+     */
+    readonly RoundRobin: "RoundRobin";
+    /**
+     * Least Connection
+     */
+    readonly LeastConnection: "LeastConnection";
+};
+/**
+ * IPVS scheduler, for more information please see http://www.linuxvirtualserver.org/docs/scheduling.html.
+ */
+export declare type IpvsScheduler = (typeof IpvsScheduler)[keyof typeof IpvsScheduler];
+export declare const KeyVaultNetworkAccessTypes: {
+    readonly Public: "Public";
+    readonly Private: "Private";
+};
+/**
+ * Network access of key vault. The possible values are `Public` and `Private`. `Public` means the key vault allows public access from all networks. `Private` means the key vault disables public access and enables private link. The default value is `Public`.
+ */
+export declare type KeyVaultNetworkAccessTypes = (typeof KeyVaultNetworkAccessTypes)[keyof typeof KeyVaultNetworkAccessTypes];
+export declare const KubeletDiskType: {
+    /**
+     * Kubelet will use the OS disk for its data.
+     */
+    readonly OS: "OS";
+    /**
+     * Kubelet will use the temporary disk for its data.
+     */
+    readonly Temporary: "Temporary";
+};
+/**
+ * Determines the placement of emptyDir volumes, container runtime data root, and Kubelet ephemeral storage.
+ */
+export declare type KubeletDiskType = (typeof KubeletDiskType)[keyof typeof KubeletDiskType];
+export declare const Level: {
+    readonly Off: "Off";
+    readonly Warning: "Warning";
+    readonly Enforcement: "Enforcement";
+};
+/**
+ * The guardrails level to be used. By default, Guardrails is enabled for all namespaces except those that AKS excludes via systemExcludedNamespaces
+ */
+export declare type Level = (typeof Level)[keyof typeof Level];
+export declare const LicenseType: {
+    /**
+     * No additional licensing is applied.
+     */
+    readonly None: "None";
+    /**
+     * Enables Azure Hybrid User Benefits for Windows VMs.
+     */
+    readonly Windows_Server: "Windows_Server";
+};
+/**
+ * The license type to use for Windows VMs. See [Azure Hybrid User Benefits](https://azure.microsoft.com/pricing/hybrid-benefit/faq/) for more details.
+ */
+export declare type LicenseType = (typeof LicenseType)[keyof typeof LicenseType];
+export declare const LoadBalancerSku: {
+    /**
+     * Use a a standard Load Balancer. This is the recommended Load Balancer SKU. For more information about on working with the load balancer in the managed cluster, see the [standard Load Balancer](https://docs.microsoft.com/azure/aks/load-balancer-standard) article.
+     */
+    readonly Standard: "standard";
+    /**
+     * Use a basic Load Balancer with limited functionality.
+     */
+    readonly Basic: "basic";
+};
+/**
+ * The default is 'standard'. See [Azure Load Balancer SKUs](https://docs.microsoft.com/azure/load-balancer/skus) for more information about the differences between load balancer SKUs.
+ */
+export declare type LoadBalancerSku = (typeof LoadBalancerSku)[keyof typeof LoadBalancerSku];
+export declare const ManagedClusterSKUName: {
+    readonly Basic: "Basic";
+};
+/**
+ * The name of a managed cluster SKU.
+ */
+export declare type ManagedClusterSKUName = (typeof ManagedClusterSKUName)[keyof typeof ManagedClusterSKUName];
+export declare const ManagedClusterSKUTier: {
+    /**
+     * Guarantees 99.95% availability of the Kubernetes API server endpoint for clusters that use Availability Zones and 99.9% of availability for clusters that don't use Availability Zones.
+     */
+    readonly Paid: "Paid";
+    /**
+     * No guaranteed SLA, no additional charges. Free tier clusters have an SLO of 99.5%.
+     */
+    readonly Free: "Free";
+};
+/**
+ * If not specified, the default is 'Free'. See [uptime SLA](https://docs.microsoft.com/azure/aks/uptime-sla) for more details.
+ */
+export declare type ManagedClusterSKUTier = (typeof ManagedClusterSKUTier)[keyof typeof ManagedClusterSKUTier];
+export declare const Mode: {
+    /**
+     * IPTables proxy mode
+     */
+    readonly IPTABLES: "IPTABLES";
+    /**
+     * IPVS proxy mode. Must be using Kubernetes version >= 1.22.
+     */
+    readonly IPVS: "IPVS";
+};
+/**
+ * Specify which proxy mode to use ('IPTABLES' or 'IPVS')
+ */
+export declare type Mode = (typeof Mode)[keyof typeof Mode];
+export declare const NetworkMode: {
+    /**
+     * No bridge is created. Intra-VM Pod to Pod communication is through IP routes created by Azure CNI. See [Transparent Mode](https://docs.microsoft.com/azure/aks/faq#transparent-mode) for more information.
+     */
+    readonly Transparent: "transparent";
+    /**
+     * This is no longer supported
+     */
+    readonly Bridge: "bridge";
+};
+/**
+ * This cannot be specified if networkPlugin is anything other than 'azure'.
+ */
+export declare type NetworkMode = (typeof NetworkMode)[keyof typeof NetworkMode];
+export declare const NetworkPlugin: {
+    /**
+     * Use the Azure CNI network plugin. See [Azure CNI (advanced) networking](https://docs.microsoft.com/azure/aks/concepts-network#azure-cni-advanced-networking) for more information.
+     */
+    readonly Azure: "azure";
+    /**
+     * Use the Kubenet network plugin. See [Kubenet (basic) networking](https://docs.microsoft.com/azure/aks/concepts-network#kubenet-basic-networking) for more information.
+     */
+    readonly Kubenet: "kubenet";
+    /**
+     * Do not use a network plugin. A custom CNI will need to be installed after cluster creation for networking functionality.
+     */
+    readonly None: "none";
+};
+/**
+ * Network plugin used for building the Kubernetes network.
+ */
+export declare type NetworkPlugin = (typeof NetworkPlugin)[keyof typeof NetworkPlugin];
+export declare const NetworkPluginMode: {
+    /**
+     * Pods are given IPs from the PodCIDR address space but use Azure Routing Domains rather than Kubenet reference plugins host-local and bridge.
+     */
+    readonly Overlay: "Overlay";
+};
+/**
+ * Network plugin mode used for building the Kubernetes network.
+ */
+export declare type NetworkPluginMode = (typeof NetworkPluginMode)[keyof typeof NetworkPluginMode];
+export declare const NetworkPolicy: {
+    /**
+     * Use Calico network policies. See [differences between Azure and Calico policies](https://docs.microsoft.com/azure/aks/use-network-policies#differences-between-azure-and-calico-policies-and-their-capabilities) for more information.
+     */
+    readonly Calico: "calico";
+    /**
+     * Use Azure network policies. See [differences between Azure and Calico policies](https://docs.microsoft.com/azure/aks/use-network-policies#differences-between-azure-and-calico-policies-and-their-capabilities) for more information.
+     */
+    readonly Azure: "azure";
+};
+/**
+ * Network policy used for building the Kubernetes network.
+ */
+export declare type NetworkPolicy = (typeof NetworkPolicy)[keyof typeof NetworkPolicy];
+export declare const OSDiskType: {
+    /**
+     * Azure replicates the operating system disk for a virtual machine to Azure storage to avoid data loss should the VM need to be relocated to another host. Since containers aren't designed to have local state persisted, this behavior offers limited value while providing some drawbacks, including slower node provisioning and higher read/write latency.
+     */
+    readonly Managed: "Managed";
+    /**
+     * Ephemeral OS disks are stored only on the host machine, just like a temporary disk. This provides lower read/write latency, along with faster node scaling and cluster upgrades.
+     */
+    readonly Ephemeral: "Ephemeral";
+};
+/**
+ * The default is 'Ephemeral' if the VM supports it and has a cache disk larger than the requested OSDiskSizeGB. Otherwise, defaults to 'Managed'. May not be changed after creation. For more information see [Ephemeral OS](https://docs.microsoft.com/azure/aks/cluster-configuration#ephemeral-os).
+ */
+export declare type OSDiskType = (typeof OSDiskType)[keyof typeof OSDiskType];
+export declare const OSSKU: {
+    readonly Ubuntu: "Ubuntu";
+    readonly CBLMariner: "CBLMariner";
+    readonly Mariner: "Mariner";
+    readonly Windows2019: "Windows2019";
+    readonly Windows2022: "Windows2022";
+};
+/**
+ * Specifies the OS SKU used by the agent pool. If not specified, the default is Ubuntu if OSType=Linux or Windows2019 if OSType=Windows. And the default Windows OSSKU will be changed to Windows2022 after Windows2019 is deprecated.
+ */
+export declare type OSSKU = (typeof OSSKU)[keyof typeof OSSKU];
+export declare const OSType: {
+    /**
+     * Use Linux.
+     */
+    readonly Linux: "Linux";
+    /**
+     * Use Windows.
+     */
+    readonly Windows: "Windows";
+};
+/**
+ * The operating system type. The default is Linux.
+ */
+export declare type OSType = (typeof OSType)[keyof typeof OSType];
+export declare const OutboundType: {
+    /**
+     * The load balancer is used for egress through an AKS assigned public IP. This supports Kubernetes services of type 'loadBalancer'. For more information see [outbound type loadbalancer](https://docs.microsoft.com/azure/aks/egress-outboundtype#outbound-type-of-loadbalancer).
+     */
+    readonly LoadBalancer: "loadBalancer";
+    /**
+     * Egress paths must be defined by the user. This is an advanced scenario and requires proper network configuration. For more information see [outbound type userDefinedRouting](https://docs.microsoft.com/azure/aks/egress-outboundtype#outbound-type-of-userdefinedrouting).
+     */
+    readonly UserDefinedRouting: "userDefinedRouting";
+    /**
+     * The AKS-managed NAT gateway is used for egress.
+     */
+    readonly ManagedNATGateway: "managedNATGateway";
+    /**
+     * The user-assigned NAT gateway associated to the cluster subnet is used for egress. This is an advanced scenario and requires proper network configuration.
+     */
+    readonly UserAssignedNATGateway: "userAssignedNATGateway";
+};
+/**
+ * This can only be set at cluster creation time and cannot be changed later. For more information see [egress outbound type](https://docs.microsoft.com/azure/aks/egress-outboundtype).
+ */
+export declare type OutboundType = (typeof OutboundType)[keyof typeof OutboundType];
+export declare const PublicNetworkAccess: {
+    /**
+     * Inbound/Outbound to the managedCluster is allowed.
+     */
+    readonly Enabled: "Enabled";
+    /**
+     * Inbound traffic to managedCluster is disabled, traffic from managedCluster is allowed.
+     */
+    readonly Disabled: "Disabled";
+    /**
+     * Inbound/Outbound traffic is managed by Microsoft.Network/NetworkSecurityPerimeters.
+     */
+    readonly SecuredByPerimeter: "SecuredByPerimeter";
+};
+/**
+ * Allow or deny public network access for AKS
+ */
+export declare type PublicNetworkAccess = (typeof PublicNetworkAccess)[keyof typeof PublicNetworkAccess];
+export declare const ResourceIdentityType: {
+    /**
+     * Use an implicitly created system assigned managed identity to manage cluster resources. Master components in the control plane such as kube-controller-manager will use the system assigned managed identity to manipulate Azure resources.
+     */
+    readonly SystemAssigned: "SystemAssigned";
+    /**
+     * Use a user-specified identity to manage cluster resources. Master components in the control plane such as kube-controller-manager will use the specified user assigned managed identity to manipulate Azure resources.
+     */
+    readonly UserAssigned: "UserAssigned";
+    /**
+     * Do not use a managed identity for the Managed Cluster, service principal will be used instead.
+     */
+    readonly None: "None";
+};
+/**
+ * For more information see [use managed identities in AKS](https://docs.microsoft.com/azure/aks/use-managed-identity).
+ */
+export declare type ResourceIdentityType = (typeof ResourceIdentityType)[keyof typeof ResourceIdentityType];
+export declare const ScaleDownMode: {
+    /**
+     * Create new instances during scale up and remove instances during scale down.
+     */
+    readonly Delete: "Delete";
+    /**
+     * Attempt to start deallocated instances (if they exist) during scale up and deallocate instances during scale down.
+     */
+    readonly Deallocate: "Deallocate";
+};
+/**
+ * This also effects the cluster autoscaler behavior. If not specified, it defaults to Delete.
+ */
+export declare type ScaleDownMode = (typeof ScaleDownMode)[keyof typeof ScaleDownMode];
+export declare const ScaleSetEvictionPolicy: {
+    /**
+     * Nodes in the underlying Scale Set of the node pool are deleted when they're evicted.
+     */
+    readonly Delete: "Delete";
+    /**
+     * Nodes in the underlying Scale Set of the node pool are set to the stopped-deallocated state upon eviction. Nodes in the stopped-deallocated state count against your compute quota and can cause issues with cluster scaling or upgrading.
+     */
+    readonly Deallocate: "Deallocate";
+};
+/**
+ * This cannot be specified unless the scaleSetPriority is 'Spot'. If not specified, the default is 'Delete'.
+ */
+export declare type ScaleSetEvictionPolicy = (typeof ScaleSetEvictionPolicy)[keyof typeof ScaleSetEvictionPolicy];
+export declare const ScaleSetPriority: {
+    /**
+     * Spot priority VMs will be used. There is no SLA for spot nodes. See [spot on AKS](https://docs.microsoft.com/azure/aks/spot-node-pool) for more information.
+     */
+    readonly Spot: "Spot";
+    /**
+     * Regular VMs will be used.
+     */
+    readonly Regular: "Regular";
+};
+/**
+ * The Virtual Machine Scale Set priority. If not specified, the default is 'Regular'.
+ */
+export declare type ScaleSetPriority = (typeof ScaleSetPriority)[keyof typeof ScaleSetPriority];
+export declare const SnapshotType: {
+    /**
+     * The snapshot is a snapshot of a node pool.
+     */
+    readonly NodePool: "NodePool";
+    /**
+     * The snapshot is a snapshot of a managed cluster.
+     */
+    readonly ManagedCluster: "ManagedCluster";
+};
+/**
+ * The type of a snapshot. The default is NodePool.
+ */
+export declare type SnapshotType = (typeof SnapshotType)[keyof typeof SnapshotType];
+export declare const UpdateMode: {
+    /**
+     * Autoscaler never changes pod resources but provides recommendations.
+     */
+    readonly Off: "Off";
+    /**
+     * Autoscaler only assigns resources on pod creation and doesn't change them during the lifetime of the pod.
+     */
+    readonly Initial: "Initial";
+    /**
+     * Autoscaler assigns resources on pod creation and updates pods that need further scaling during their lifetime by deleting and recreating.
+     */
+    readonly Recreate: "Recreate";
+    /**
+     * Autoscaler chooses the update mode. Autoscaler currently does the same as Recreate. In the future, it may take advantage of restart-free mechanisms once they are available.
+     */
+    readonly Auto: "Auto";
+};
+/**
+ * Each update mode level is a superset of the lower levels. Off<Initial<Recreate<=Auto. For example: if UpdateMode is Initial, it means VPA sets the recommended resources in the VerticalPodAutoscaler Custom Resource (from UpdateMode Off) and also assigns resources on pod creation (from Initial). The default value is Off.
+ */
+export declare type UpdateMode = (typeof UpdateMode)[keyof typeof UpdateMode];
+export declare const UpgradeChannel: {
+    /**
+     * Automatically upgrade the cluster to the latest supported patch release on the latest supported minor version. In cases where the cluster is at a version of Kubernetes that is at an N-2 minor version where N is the latest supported minor version, the cluster first upgrades to the latest supported patch version on N-1 minor version. For example, if a cluster is running version 1.17.7 and versions 1.17.9, 1.18.4, 1.18.6, and 1.19.1 are available, your cluster first is upgraded to 1.18.6, then is upgraded to 1.19.1.
+     */
+    readonly Rapid: "rapid";
+    /**
+     * Automatically upgrade the cluster to the latest supported patch release on minor version N-1, where N is the latest supported minor version. For example, if a cluster is running version 1.17.7 and versions 1.17.9, 1.18.4, 1.18.6, and 1.19.1 are available, your cluster is upgraded to 1.18.6.
+     */
+    readonly Stable: "stable";
+    /**
+     * Automatically upgrade the cluster to the latest supported patch version when it becomes available while keeping the minor version the same. For example, if a cluster is running version 1.17.7 and versions 1.17.9, 1.18.4, 1.18.6, and 1.19.1 are available, your cluster is upgraded to 1.17.9.
+     */
+    readonly Patch: "patch";
+    /**
+     * Automatically upgrade the node image to the latest version available. Microsoft provides patches and new images for image nodes frequently (usually weekly), but your running nodes won't get the new images unless you do a node image upgrade. Turning on the node-image channel will automatically update your node images whenever a new version is available.
+     */
+    readonly Node_image: "node-image";
+    /**
+     * Disables auto-upgrades and keeps the cluster at its current version of Kubernetes.
+     */
+    readonly None: "none";
+};
+/**
+ * For more information see [setting the AKS cluster auto-upgrade channel](https://docs.microsoft.com/azure/aks/upgrade-cluster#set-auto-upgrade-channel).
+ */
+export declare type UpgradeChannel = (typeof UpgradeChannel)[keyof typeof UpgradeChannel];
+export declare const WeekDay: {
+    readonly Sunday: "Sunday";
+    readonly Monday: "Monday";
+    readonly Tuesday: "Tuesday";
+    readonly Wednesday: "Wednesday";
+    readonly Thursday: "Thursday";
+    readonly Friday: "Friday";
+    readonly Saturday: "Saturday";
+};
+/**
+ * The day of the week.
+ */
+export declare type WeekDay = (typeof WeekDay)[keyof typeof WeekDay];
+export declare const WorkloadRuntime: {
+    /**
+     * Nodes will use Kubelet to run standard OCI container workloads.
+     */
+    readonly OCIContainer: "OCIContainer";
+    /**
+     * Nodes will use Krustlet to run WASM workloads using the WASI provider (Preview).
+     */
+    readonly WasmWasi: "WasmWasi";
+};
+/**
+ * Determines the type of workload a node can run.
+ */
+export declare type WorkloadRuntime = (typeof WorkloadRuntime)[keyof typeof WorkloadRuntime];