@pulumi/azure-native
Version:
[](https://slack.pulumi.com) [](https://npmjs.com/package/@pulumi/azure-native) [ • 44.1 kB
TypeScript
export declare const AdoptionPolicy: {
/**
* If the namespace already exists in Kubernetes, attempts to create that same namespace in ARM will fail.
*/
readonly Never: "Never";
/**
* Take over the existing namespace to be managed by ARM, if there is no difference.
*/
readonly IfIdentical: "IfIdentical";
/**
* Always take over the existing namespace to be managed by ARM, some fields might be overwritten.
*/
readonly Always: "Always";
};
/**
* Action if Kubernetes namespace with same name already exists.
*/
export type AdoptionPolicy = (typeof AdoptionPolicy)[keyof typeof AdoptionPolicy];
export declare const AdvancedNetworkPolicies: {
/**
* Enable Layer7 network policies (FQDN, HTTP/S, Kafka). This option is a superset of the FQDN option.
*/
readonly L7: "L7";
/**
* Enable FQDN based network policies
*/
readonly FQDN: "FQDN";
/**
* Disable Layer 7 network policies (FQDN, HTTP/S, Kafka)
*/
readonly None: "None";
};
/**
* Enable advanced network policies. This allows users to configure Layer 7 network policies (FQDN, HTTP, Kafka). Policies themselves must be configured via the Cilium Network Policy resources, see https://docs.cilium.io/en/latest/security/policy/index.html. This can be enabled only on cilium-based clusters. If not specified, the default value is FQDN if security.enabled is set to true.
*/
export type AdvancedNetworkPolicies = (typeof AdvancedNetworkPolicies)[keyof typeof AdvancedNetworkPolicies];
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";
/**
* Gateway agent pools are dedicated to providing static egress IPs to pods. For more details, see https://aka.ms/aks/static-egress-gateway.
*/
readonly Gateway: "Gateway";
};
/**
* The mode of an agent pool. 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 type AgentPoolMode = (typeof AgentPoolMode)[keyof typeof AgentPoolMode];
export declare const AgentPoolSSHAccess: {
/**
* Can SSH onto the node as a local user using private key.
*/
readonly LocalUser: "LocalUser";
/**
* SSH service will be turned off on the node.
*/
readonly Disabled: "Disabled";
};
/**
* SSH access method of an agent pool.
*/
export type AgentPoolSSHAccess = (typeof AgentPoolSSHAccess)[keyof typeof AgentPoolSSHAccess];
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";
/**
* Create an Agent Pool backed by a Single Instance VM orchestration mode.
*/
readonly VirtualMachines: "VirtualMachines";
};
/**
* The type of Agent Pool.
*/
export type AgentPoolType = (typeof AgentPoolType)[keyof typeof AgentPoolType];
export declare const ArtifactSource: {
/**
* pull images from Azure Container Registry with cache
*/
readonly Cache: "Cache";
/**
* pull images from Microsoft Artifact Registry
*/
readonly Direct: "Direct";
};
/**
* The artifact source. The source where the artifacts are downloaded from.
*/
export type ArtifactSource = (typeof ArtifactSource)[keyof typeof ArtifactSource];
export declare const AutoUpgradeNodeImageSelectionType: {
/**
* Use the latest image version when upgrading nodes. Clusters may use different image versions (e.g., 'AKSUbuntu-1804gen2containerd-2021.10.12' and 'AKSUbuntu-1804gen2containerd-2021.10.19') because, for example, the latest available version is different in different regions.
*/
readonly Latest: "Latest";
/**
* The image versions to upgrade nodes to are selected as described below: for each node pool in managed clusters affected by the update run, the system selects the latest image version such that it is available across all other node pools (in all other clusters) of the same image type. As a result, all node pools of the same image type will be upgraded to the same image version. For example, if the latest image version for image type 'AKSUbuntu-1804gen2containerd' is 'AKSUbuntu-1804gen2containerd-2021.10.12' for a node pool in cluster A in region X, and is 'AKSUbuntu-1804gen2containerd-2021.10.17' for a node pool in cluster B in region Y, the system will upgrade both node pools to image version 'AKSUbuntu-1804gen2containerd-2021.10.12'.
*/
readonly Consistent: "Consistent";
};
/**
* The node image upgrade type.
*/
export type AutoUpgradeNodeImageSelectionType = (typeof AutoUpgradeNodeImageSelectionType)[keyof typeof AutoUpgradeNodeImageSelectionType];
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 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 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 type ConnectionStatus = (typeof ConnectionStatus)[keyof typeof ConnectionStatus];
export declare const DeletePolicy: {
/**
* Only delete the ARM resource, keep the Kubernetes namespace. Also delete the ManagedByARM label.
*/
readonly Keep: "Keep";
/**
* Delete both the ARM resource and the Kubernetes namespace together.
*/
readonly Delete: "Delete";
};
/**
* Delete options of a namespace.
*/
export type DeletePolicy = (typeof DeletePolicy)[keyof typeof DeletePolicy];
export declare const DeploymentSafeguardsLevel: {
/**
* Best practice violations will only show warnings
*/
readonly Warn: "Warn";
/**
* Best practice violations will be denied
*/
readonly Enforce: "Enforce";
};
/**
* The deployment safeguards level. Possible values are Warn and Enforce
*/
export type DeploymentSafeguardsLevel = (typeof DeploymentSafeguardsLevel)[keyof typeof DeploymentSafeguardsLevel];
export declare const ExecutionPoint: {
/**
* Execute during node image build time.
*/
readonly NodeImageBuildTime: "NodeImageBuildTime";
/**
* Execute during node provisioning time.
*/
readonly NodeProvisionTime: "NodeProvisionTime";
};
/**
* The stage at which the script is executed.
* Specifying `NodeImageBuildTime` will ensure changes are persisted into the node image.
*/
export type ExecutionPoint = (typeof ExecutionPoint)[keyof typeof ExecutionPoint];
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";
};
/**
* The expander to use when scaling up. 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 type Expander = (typeof Expander)[keyof typeof Expander];
export declare const ExtendedLocationTypes: {
readonly EdgeZone: "EdgeZone";
};
/**
* The type of the extended location.
*/
export type ExtendedLocationTypes = (typeof ExtendedLocationTypes)[keyof typeof ExtendedLocationTypes];
export declare const GPUDriver: {
/**
* Install driver.
*/
readonly Install: "Install";
/**
* Skip driver install.
*/
readonly None: "None";
};
/**
* Whether to install GPU drivers. When it's not specified, default is Install.
*/
export type GPUDriver = (typeof GPUDriver)[keyof typeof GPUDriver];
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 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 type IpFamily = (typeof IpFamily)[keyof typeof IpFamily];
export declare const IstioIngressGatewayMode: {
/**
* The ingress gateway is assigned a public IP address and is publicly accessible.
*/
readonly External: "External";
/**
* The ingress gateway is assigned an internal IP address and cannot is accessed publicly.
*/
readonly Internal: "Internal";
};
/**
* Mode of an ingress gateway.
*/
export type IstioIngressGatewayMode = (typeof IstioIngressGatewayMode)[keyof typeof IstioIngressGatewayMode];
export declare const KeyVaultNetworkAccessTypes: {
readonly Public: "Public";
readonly Private: "Private";
};
/**
* Network access of the key vault. 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 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 type KubeletDiskType = (typeof KubeletDiskType)[keyof typeof KubeletDiskType];
export declare const KubernetesSupportPlan: {
/**
* Support for the version is the same as for the open source Kubernetes offering. Official Kubernetes open source community support versions for 1 year after release.
*/
readonly KubernetesOfficial: "KubernetesOfficial";
/**
* Support for the version extended past the KubernetesOfficial support of 1 year. AKS continues to patch CVEs for another 1 year, for a total of 2 years of support.
*/
readonly AKSLongTermSupport: "AKSLongTermSupport";
};
/**
* The support plan for the Managed Cluster. If unspecified, the default is 'KubernetesOfficial'.
*/
export type KubernetesSupportPlan = (typeof KubernetesSupportPlan)[keyof typeof KubernetesSupportPlan];
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 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 load balancer sku for the managed cluster. 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 type LoadBalancerSku = (typeof LoadBalancerSku)[keyof typeof LoadBalancerSku];
export declare const ManagedClusterSKUName: {
/**
* Base option for the AKS control plane.
*/
readonly Base: "Base";
/**
* Automatic clusters are optimized to run most production workloads with configuration that follows AKS best practices and recommendations for cluster and workload setup, scalability, and security. For more details about Automatic clusters see aka.ms/aks/automatic.
*/
readonly Automatic: "Automatic";
};
/**
* The name of a managed cluster SKU.
*/
export type ManagedClusterSKUName = (typeof ManagedClusterSKUName)[keyof typeof ManagedClusterSKUName];
export declare const ManagedClusterSKUTier: {
/**
* Cluster has premium capabilities in addition to all of the capabilities included in 'Standard'. Premium enables selection of LongTermSupport (aka.ms/aks/lts) for certain Kubernetes versions.
*/
readonly Premium: "Premium";
/**
* Recommended for mission-critical and production workloads. Includes Kubernetes control plane autoscaling, workload-intensive testing, and up to 5,000 nodes per cluster. 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 Standard: "Standard";
/**
* The cluster management is free, but charged for VM, storage, and networking usage. Best for experimenting, learning, simple testing, or workloads with fewer than 10 nodes. Not recommended for production use cases.
*/
readonly Free: "Free";
};
/**
* The tier of a managed cluster SKU. If not specified, the default is 'Free'. See [AKS Pricing Tier](https://learn.microsoft.com/azure/aks/free-standard-pricing-tiers) for more details.
*/
export type ManagedClusterSKUTier = (typeof ManagedClusterSKUTier)[keyof typeof ManagedClusterSKUTier];
export declare const ManagedClusterUpgradeType: {
/**
* Full upgrades the control plane and all agent pools of the target ManagedClusters. Requires the ManagedClusterUpgradeSpec.KubernetesVersion property to be set.
*/
readonly Full: "Full";
/**
* NodeImageOnly upgrades only the node images of the target ManagedClusters. Requires the ManagedClusterUpgradeSpec.KubernetesVersion property to NOT be set.
*/
readonly NodeImageOnly: "NodeImageOnly";
/**
* ControlPlaneOnly upgrades only targets the KubernetesVersion of the ManagedClusters and will not be applied to the AgentPool. Requires the ManagedClusterUpgradeSpec.KubernetesVersion property to be set.
*/
readonly ControlPlaneOnly: "ControlPlaneOnly";
};
/**
* ManagedClusterUpgradeType is the type of upgrade to be applied.
*/
export type ManagedClusterUpgradeType = (typeof ManagedClusterUpgradeType)[keyof typeof ManagedClusterUpgradeType];
export declare const ManagedServiceIdentityType: {
readonly None: "None";
readonly SystemAssigned: "SystemAssigned";
readonly UserAssigned: "UserAssigned";
readonly SystemAssigned_UserAssigned: "SystemAssigned, UserAssigned";
};
/**
* Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
*/
export type ManagedServiceIdentityType = (typeof ManagedServiceIdentityType)[keyof typeof ManagedServiceIdentityType];
export declare const NetworkDataplane: {
/**
* Use Azure network dataplane.
*/
readonly Azure: "azure";
/**
* Use Cilium network dataplane. See [Azure CNI Powered by Cilium](https://learn.microsoft.com/azure/aks/azure-cni-powered-by-cilium) for more information.
*/
readonly Cilium: "cilium";
};
/**
* Network dataplane used in the Kubernetes cluster.
*/
export type NetworkDataplane = (typeof NetworkDataplane)[keyof typeof NetworkDataplane];
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";
};
/**
* The network mode Azure CNI is configured with. This cannot be specified if networkPlugin is anything other than 'azure'.
*/
export 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";
/**
* No CNI plugin is pre-installed. See [BYO CNI](https://docs.microsoft.com/en-us/azure/aks/use-byo-cni) for more information.
*/
readonly None: "none";
};
/**
* Network plugin used for building the Kubernetes network.
*/
export type NetworkPlugin = (typeof NetworkPlugin)[keyof typeof NetworkPlugin];
export declare const NetworkPluginMode: {
/**
* Used with networkPlugin=azure, pods are given IPs from the PodCIDR address space but use Azure Routing Domains rather than Kubenet's method of route tables. For more information visit https://aka.ms/aks/azure-cni-overlay.
*/
readonly Overlay: "overlay";
};
/**
* The mode the network plugin should use.
*/
export type NetworkPluginMode = (typeof NetworkPluginMode)[keyof typeof NetworkPluginMode];
export declare const NetworkPolicy: {
/**
* Network policies will not be enforced. This is the default value when NetworkPolicy is not specified.
*/
readonly None: "none";
/**
* 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";
/**
* Use Cilium to enforce network policies. This requires networkDataplane to be 'cilium'.
*/
readonly Cilium: "cilium";
};
/**
* Network policy used for building the Kubernetes network.
*/
export type NetworkPolicy = (typeof NetworkPolicy)[keyof typeof NetworkPolicy];
export declare const NginxIngressControllerType: {
/**
* The default NginxIngressController will be created. Users can edit the default NginxIngressController Custom Resource to configure load balancer annotations.
*/
readonly AnnotationControlled: "AnnotationControlled";
/**
* The default NginxIngressController will be created and the operator will provision an external loadbalancer with it. Any annotation to make the default loadbalancer internal will be overwritten.
*/
readonly External: "External";
/**
* The default NginxIngressController will be created and the operator will provision an internal loadbalancer with it. Any annotation to make the default loadbalancer external will be overwritten.
*/
readonly Internal: "Internal";
/**
* The default Ingress Controller will not be created. It will not be deleted by the system if it exists. Users should delete the default NginxIngressController Custom Resource manually if desired.
*/
readonly None: "None";
};
/**
* Ingress type for the default NginxIngressController custom resource
*/
export type NginxIngressControllerType = (typeof NginxIngressControllerType)[keyof typeof NginxIngressControllerType];
export declare const NodeImageSelectionType: {
/**
* Use the latest image version when upgrading nodes. Clusters may use different image versions (e.g., 'AKSUbuntu-1804gen2containerd-2021.10.12' and 'AKSUbuntu-1804gen2containerd-2021.10.19') because, for example, the latest available version is different in different regions.
*/
readonly Latest: "Latest";
/**
* The image versions to upgrade nodes to are selected as described below: for each node pool in managed clusters affected by the update run, the system selects the latest image version such that it is available across all other node pools (in all other clusters) of the same image type. As a result, all node pools of the same image type will be upgraded to the same image version. For example, if the latest image version for image type 'AKSUbuntu-1804gen2containerd' is 'AKSUbuntu-1804gen2containerd-2021.10.12' for a node pool in cluster A in region X, and is 'AKSUbuntu-1804gen2containerd-2021.10.17' for a node pool in cluster B in region Y, the system will upgrade both node pools to image version 'AKSUbuntu-1804gen2containerd-2021.10.12'.
*/
readonly Consistent: "Consistent";
/**
* Upgrade the nodes to the custom image versions. When set, update run will use node image versions provided in customNodeImageVersions to upgrade the nodes. If set, customNodeImageVersions must not be empty.
*/
readonly Custom: "Custom";
};
/**
* The node image upgrade type.
*/
export type NodeImageSelectionType = (typeof NodeImageSelectionType)[keyof typeof NodeImageSelectionType];
export declare const NodeOSUpgradeChannel: {
/**
* No attempt to update your machines OS will be made either by OS or by rolling VHDs. This means you are responsible for your security updates
*/
readonly None: "None";
/**
* OS updates will be applied automatically through the OS built-in patching infrastructure. Newly scaled in machines will be unpatched initially and will be patched at some point by the OS's infrastructure. Behavior of this option depends on the OS in question. Ubuntu and Mariner apply security patches through unattended upgrade roughly once a day around 06:00 UTC. Windows does not apply security patches automatically and so for them this option is equivalent to None till further notice
*/
readonly Unmanaged: "Unmanaged";
/**
* AKS will update the nodes with a newly patched VHD containing security fixes and bugfixes on a weekly cadence. With the VHD update machines will be rolling reimaged to that VHD following maintenance windows and surge settings. No extra VHD cost is incurred when choosing this option as AKS hosts the images.
*/
readonly NodeImage: "NodeImage";
/**
* AKS downloads and updates the nodes with tested security updates. These updates honor the maintenance window settings and produce a new VHD that is used on new nodes. On some occasions it's not possible to apply the updates in place, in such cases the existing nodes will also be re-imaged to the newly produced VHD in order to apply the changes. This option incurs an extra cost of hosting the new Security Patch VHDs in your resource group for just in time consumption.
*/
readonly SecurityPatch: "SecurityPatch";
};
/**
* Node OS Upgrade Channel. Manner in which the OS on your nodes is updated. The default is NodeImage.
*/
export type NodeOSUpgradeChannel = (typeof NodeOSUpgradeChannel)[keyof typeof NodeOSUpgradeChannel];
export declare const NodeProvisioningDefaultNodePools: {
/**
* No Karpenter NodePools are provisioned automatically. Automatic scaling will not happen unless the user creates one or more NodePool CRD instances.
*/
readonly None: "None";
/**
* A standard set of Karpenter NodePools are provisioned
*/
readonly Auto: "Auto";
};
/**
* The set of default Karpenter NodePools (CRDs) configured for node provisioning. This field has no effect unless mode is 'Auto'. Warning: Changing this from Auto to None on an existing cluster will cause the default Karpenter NodePools to be deleted, which will drain and delete the nodes associated with those pools. It is strongly recommended to not do this unless there are idle nodes ready to take the pods evicted by that action. If not specified, the default is Auto. For more information see aka.ms/aks/nap#node-pools.
*/
export type NodeProvisioningDefaultNodePools = (typeof NodeProvisioningDefaultNodePools)[keyof typeof NodeProvisioningDefaultNodePools];
export declare const NodeProvisioningMode: {
/**
* Nodes are provisioned manually by the user
*/
readonly Manual: "Manual";
/**
* Nodes are provisioned automatically by AKS using Karpenter (See aka.ms/aks/nap for more details). Fixed size Node Pools can still be created, but autoscaling Node Pools cannot be. (See aka.ms/aks/nap for more details).
*/
readonly Auto: "Auto";
};
/**
* The node provisioning mode. If not specified, the default is Manual.
*/
export type NodeProvisioningMode = (typeof NodeProvisioningMode)[keyof typeof NodeProvisioningMode];
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 OS disk type to be used for machines in the agent pool. 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 type OSDiskType = (typeof OSDiskType)[keyof typeof OSDiskType];
export declare const OSSKU: {
/**
* Use Ubuntu as the OS for node images.
*/
readonly Ubuntu: "Ubuntu";
/**
* Use AzureLinux as the OS for node images. Azure Linux is a container-optimized Linux distro built by Microsoft, visit https://aka.ms/azurelinux for more information.
*/
readonly AzureLinux: "AzureLinux";
/**
* Use AzureLinux3 as the OS for node images. Azure Linux is a container-optimized Linux distro built by Microsoft, visit https://aka.ms/azurelinux for more information. For limitations, visit https://aka.ms/aks/node-images. For OS migration guidance, see https://aka.ms/aks/upgrade-os-version.
*/
readonly AzureLinux3: "AzureLinux3";
/**
* Deprecated OSSKU. Microsoft recommends that new deployments choose 'AzureLinux' instead.
*/
readonly CBLMariner: "CBLMariner";
/**
* Use Windows2019 as the OS for node images. Unsupported for system node pools. Windows2019 only supports Windows2019 containers; it cannot run Windows2022 containers and vice versa.
*/
readonly Windows2019: "Windows2019";
/**
* Use Windows2022 as the OS for node images. Unsupported for system node pools. Windows2022 only supports Windows2022 containers; it cannot run Windows2019 containers and vice versa.
*/
readonly Windows2022: "Windows2022";
/**
* Use Ubuntu2204 as the OS for node images, however, Ubuntu 22.04 may not be supported for all nodepools. For limitations and supported kubernetes versions, see https://aka.ms/aks/supported-ubuntu-versions
*/
readonly Ubuntu2204: "Ubuntu2204";
};
/**
* Specifies the OS SKU used by the agent pool. The default is Ubuntu if OSType is Linux. The default is Windows2019 when Kubernetes <= 1.24 or Windows2022 when Kubernetes >= 1.25 if OSType is Windows.
*/
export 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 type OSType = (typeof OSType)[keyof typeof OSType];
export declare const Operator: {
/**
* The value of the key should be in the given list.
*/
readonly In: "In";
/**
* The value of the key should not be in the given list.
*/
readonly NotIn: "NotIn";
/**
* The value of the key should exist.
*/
readonly Exists: "Exists";
/**
* The value of the key should not exist.
*/
readonly DoesNotExist: "DoesNotExist";
};
/**
* operator represents a key's relationship to a set of values. Valid operators are In and NotIn
*/
export type Operator = (typeof Operator)[keyof typeof Operator];
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";
/**
* The AKS cluster is not set with any outbound-type. All AKS nodes follows Azure VM default outbound behavior. Please refer to https://azure.microsoft.com/en-us/updates/default-outbound-access-for-vms-in-azure-will-be-retired-transition-to-a-new-method-of-internet-access/
*/
readonly None: "none";
};
/**
* The outbound (egress) routing method. 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 type OutboundType = (typeof OutboundType)[keyof typeof OutboundType];
export declare const PodIPAllocationMode: {
/**
* Each node gets allocated with a non-contiguous list of IP addresses assignable to pods. This is better for maximizing a small to medium subnet of size /16 or smaller. The Azure CNI cluster with dynamic IP allocation defaults to this mode if the customer does not explicitly specify a podIPAllocationMode
*/
readonly DynamicIndividual: "DynamicIndividual";
/**
* Each node is statically allocated CIDR block(s) of size /28 = 16 IPs per block to satisfy the maxPods per node. Number of CIDR blocks >= (maxPods / 16). The block, rather than a single IP, counts against the Azure Vnet Private IP limit of 65K. Therefore block mode is suitable for running larger workloads with more than the current limit of 65K pods in a cluster. This mode is better suited to scale with larger subnets of /15 or bigger
*/
readonly StaticBlock: "StaticBlock";
};
/**
* Pod IP Allocation Mode. The IP allocation mode for pods in the agent pool. Must be used with podSubnetId. The default is 'DynamicIndividual'.
*/
export type PodIPAllocationMode = (typeof PodIPAllocationMode)[keyof typeof PodIPAllocationMode];
export declare const PolicyRule: {
/**
* Deny all network traffic.
*/
readonly DenyAll: "DenyAll";
/**
* Allow all network traffic.
*/
readonly AllowAll: "AllowAll";
/**
* Allow traffic within the same namespace.
*/
readonly AllowSameNamespace: "AllowSameNamespace";
};
/**
* Ingress policy for the network.
*/
export type PolicyRule = (typeof PolicyRule)[keyof typeof PolicyRule];
export declare const Protocol: {
/**
* TCP protocol.
*/
readonly TCP: "TCP";
/**
* UDP protocol.
*/
readonly UDP: "UDP";
};
/**
* The network protocol of the port.
*/
export type Protocol = (typeof Protocol)[keyof typeof Protocol];
export declare const PublicNetworkAccess: {
readonly Enabled: "Enabled";
readonly Disabled: "Disabled";
};
/**
* PublicNetworkAccess of the managedCluster. Allow or deny public network access for AKS
*/
export 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";
};
/**
* The type of identity used for the managed cluster. For more information see [use managed identities in AKS](https://docs.microsoft.com/azure/aks/use-managed-identity).
*/
export type ResourceIdentityType = (typeof ResourceIdentityType)[keyof typeof ResourceIdentityType];
export declare const RestrictionLevel: {
/**
* All RBAC permissions are allowed on the managed node resource group
*/
readonly Unrestricted: "Unrestricted";
/**
* Only */read RBAC permissions allowed on the managed node resource group
*/
readonly ReadOnly: "ReadOnly";
};
/**
* The restriction level applied to the cluster's node resource group. If not specified, the default is 'Unrestricted'
*/
export type RestrictionLevel = (typeof RestrictionLevel)[keyof typeof RestrictionLevel];
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";
};
/**
* The scale down mode to use when scaling the Agent Pool. This also effects the cluster autoscaler behavior. If not specified, it defaults to Delete.
*/
export 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";
};
/**
* The Virtual Machine Scale Set eviction policy to use. This cannot be specified unless the scaleSetPriority is 'Spot'. If not specified, the default is 'Delete'.
*/
export 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 type ScaleSetPriority = (typeof ScaleSetPriority)[keyof typeof ScaleSetPriority];
export declare const ScriptType: {
/**
* Bash script.
*/
readonly Bash: "Bash";
/**
* PowerShell script.
*/
readonly PowerShell: "PowerShell";
};
/**
* The runtime environment for the script (e.g. Bash).
*/
export type ScriptType = (typeof ScriptType)[keyof typeof ScriptType];
export declare const ServiceMeshMode: {
/**
* Istio deployed as an AKS addon.
*/
readonly Istio: "Istio";
/**
* Mesh is disabled.
*/
readonly Disabled: "Disabled";
};
/**
* Mode of the service mesh.
*/
export type ServiceMeshMode = (typeof ServiceMeshMode)[keyof typeof ServiceMeshMode];
export declare const SnapshotType: {
/**
* The snapshot is a snapshot of a node pool.
*/
readonly NodePool: "NodePool";
};
/**
* The type of a snapshot. The default is NodePool.
*/
export type SnapshotType = (typeof SnapshotType)[keyof typeof SnapshotType];
export declare const Type: {
/**
* First week of the month.
*/
readonly First: "First";
/**
* Second week of the month.
*/
readonly Second: "Second";
/**
* Third week of the month.
*/
readonly Third: "Third";
/**
* Fourth week of the month.
*/
readonly Fourth: "Fourth";
/**
* Last week of the month.
*/
readonly Last: "Last";
};
/**
* The week index. Specifies on which week of the month the dayOfWeek applies.
*/
export type Type = (typeof Type)[keyof typeof Type];
export declare const UndrainableNodeBehavior: {
/**
* AKS will cordon the blocked nodes and replace them with surge nodes during upgrade. The blocked nodes will be cordoned and replaced by surge nodes. The blocked nodes will have label 'kubernetes.azure.com/upgrade-status:Quarantined'. A surge node will be retained for each blocked node. A best-effort attempt will be made to delete all other surge nodes. If there are enough surge nodes to replace blocked nodes, then the upgrade operation and the managed cluster will be in failed state. Otherwise, the upgrade operation and the managed cluster will be in canceled state.
*/
readonly Cordon: "Cordon";
/**
* AKS will mark the blocked nodes schedulable, but the blocked nodes are not upgraded. A best-effort attempt will be made to delete all surge nodes. The upgrade operation and the managed cluster will be in failed state if there are any blocked nodes.
*/
readonly Schedule: "Schedule";
};
/**
* Defines the behavior for undrainable nodes during upgrade. The most common cause of undrainable nodes is Pod Disruption Budgets (PDBs), but other issues, such as pod termination grace period is exceeding the remaining per-node drain timeout or pod is still being in a running state, can also cause undrainable nodes.
*/
export type UndrainableNodeBehavior = (typeof UndrainableNodeBehavior)[keyof typeof UndrainableNodeBehavior];
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. Consider using nodeOSUpgradeChannel instead as that allows you to configure node OS patching separate from Kubernetes version patching
*/
readonly Node_image: "node-image";
/**
* Disables auto-upgrades and keeps the cluster at its current version of Kubernetes.
*/
readonly None: "none";
};
/**
* The upgrade channel for auto upgrade. The default is '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 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 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 type WorkloadRuntime = (typeof WorkloadRuntime)[keyof typeof WorkloadRuntime];