pulumi-azure-native 3.9.0a1757522298__py3-none-any.whl → 3.11.0a1761334446__py3-none-any.whl

pulumi_azure_native/containerservice/outputs.py

@@ -55,6 +55,12 @@ __all__ = [
     'IstioIngressGatewayResponse',
     'IstioPluginCertificateAuthorityResponse',
     'IstioServiceMeshResponse',
+    'JWTAuthenticatorClaimMappingExpressionResponse',
+    'JWTAuthenticatorClaimMappingsResponse',
+    'JWTAuthenticatorExtraClaimMappingExpressionResponse',
+    'JWTAuthenticatorIssuerResponse',
+    'JWTAuthenticatorPropertiesResponse',
+    'JWTAuthenticatorValidationRuleResponse',
     'KubeletConfigResponse',
     'LabelSelectorRequirementResponse',
     'LabelSelectorResponse',
@@ -115,6 +121,8 @@ __all__ = [
     'NamespacePropertiesResponse',
     'NetworkPoliciesResponse',
     'NetworkProfileForSnapshotResponse',
+    'NodeCustomizationPropertiesResponse',
+    'NodeCustomizationScriptResponse',
     'NodeImageSelectionResponse',
     'NodeImageSelectionStatusResponse',
     'NodeImageVersionResponse',
@@ -2213,6 +2221,294 @@ class IstioServiceMeshResponse(dict):
         return pulumi.get(self, "revisions")
 
 
+@pulumi.output_type
+class JWTAuthenticatorClaimMappingExpressionResponse(dict):
+    """
+    The claim mapping expression for JWTAuthenticator.
+    """
+    def __init__(__self__, *,
+                 expression: builtins.str):
+        """
+        The claim mapping expression for JWTAuthenticator.
+        :param builtins.str expression: The CEL expression used to access token claims.
+        """
+        pulumi.set(__self__, "expression", expression)
+
+    @property
+    @pulumi.getter
+    def expression(self) -> builtins.str:
+        """
+        The CEL expression used to access token claims.
+        """
+        return pulumi.get(self, "expression")
+
+
+@pulumi.output_type
+class JWTAuthenticatorClaimMappingsResponse(dict):
+    """
+    The claim mappings for JWTAuthenticator.
+    """
+    def __init__(__self__, *,
+                 username: 'outputs.JWTAuthenticatorClaimMappingExpressionResponse',
+                 extra: Optional[Sequence['outputs.JWTAuthenticatorExtraClaimMappingExpressionResponse']] = None,
+                 groups: Optional['outputs.JWTAuthenticatorClaimMappingExpressionResponse'] = None,
+                 uid: Optional['outputs.JWTAuthenticatorClaimMappingExpressionResponse'] = None):
+        """
+        The claim mappings for JWTAuthenticator.
+        :param 'JWTAuthenticatorClaimMappingExpressionResponse' username: The expression to extract username attribute from the token claims.
+        :param Sequence['JWTAuthenticatorExtraClaimMappingExpressionResponse'] extra: The expression to extract extra attribute from the token claims. When not provided, no extra attributes are extracted from the token claims.
+        :param 'JWTAuthenticatorClaimMappingExpressionResponse' groups: The expression to extract groups attribute from the token claims. When not provided, no groups are extracted from the token claims.
+        :param 'JWTAuthenticatorClaimMappingExpressionResponse' uid: The expression to extract uid attribute from the token claims. When not provided, no uid is extracted from the token claims.
+        """
+        pulumi.set(__self__, "username", username)
+        if extra is not None:
+            pulumi.set(__self__, "extra", extra)
+        if groups is not None:
+            pulumi.set(__self__, "groups", groups)
+        if uid is not None:
+            pulumi.set(__self__, "uid", uid)
+
+    @property
+    @pulumi.getter
+    def username(self) -> 'outputs.JWTAuthenticatorClaimMappingExpressionResponse':
+        """
+        The expression to extract username attribute from the token claims.
+        """
+        return pulumi.get(self, "username")
+
+    @property
+    @pulumi.getter
+    def extra(self) -> Optional[Sequence['outputs.JWTAuthenticatorExtraClaimMappingExpressionResponse']]:
+        """
+        The expression to extract extra attribute from the token claims. When not provided, no extra attributes are extracted from the token claims.
+        """
+        return pulumi.get(self, "extra")
+
+    @property
+    @pulumi.getter
+    def groups(self) -> Optional['outputs.JWTAuthenticatorClaimMappingExpressionResponse']:
+        """
+        The expression to extract groups attribute from the token claims. When not provided, no groups are extracted from the token claims.
+        """
+        return pulumi.get(self, "groups")
+
+    @property
+    @pulumi.getter
+    def uid(self) -> Optional['outputs.JWTAuthenticatorClaimMappingExpressionResponse']:
+        """
+        The expression to extract uid attribute from the token claims. When not provided, no uid is extracted from the token claims.
+        """
+        return pulumi.get(self, "uid")
+
+
+@pulumi.output_type
+class JWTAuthenticatorExtraClaimMappingExpressionResponse(dict):
+    """
+    The extra claim mapping expression for JWTAuthenticator.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "valueExpression":
+            suggest = "value_expression"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in JWTAuthenticatorExtraClaimMappingExpressionResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        JWTAuthenticatorExtraClaimMappingExpressionResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        JWTAuthenticatorExtraClaimMappingExpressionResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 key: builtins.str,
+                 value_expression: builtins.str):
+        """
+        The extra claim mapping expression for JWTAuthenticator.
+        :param builtins.str key: The key of the extra attribute.
+        :param builtins.str value_expression: The CEL expression used to extract the value of the extra attribute.
+        """
+        pulumi.set(__self__, "key", key)
+        pulumi.set(__self__, "value_expression", value_expression)
+
+    @property
+    @pulumi.getter
+    def key(self) -> builtins.str:
+        """
+        The key of the extra attribute.
+        """
+        return pulumi.get(self, "key")
+
+    @property
+    @pulumi.getter(name="valueExpression")
+    def value_expression(self) -> builtins.str:
+        """
+        The CEL expression used to extract the value of the extra attribute.
+        """
+        return pulumi.get(self, "value_expression")
+
+
+@pulumi.output_type
+class JWTAuthenticatorIssuerResponse(dict):
+    """
+    The OIDC issuer details for JWTAuthenticator.
+    """
+    def __init__(__self__, *,
+                 audiences: Sequence[builtins.str],
+                 url: builtins.str):
+        """
+        The OIDC issuer details for JWTAuthenticator.
+        :param Sequence[builtins.str] audiences: The set of acceptable audiences the JWT must be issued to. At least one is required. When multiple is set, AudienceMatchPolicy is used in API Server configuration.
+        :param builtins.str url: The issuer URL. The URL must begin with the scheme https and cannot contain a query string or fragment. This must match the "iss" claim in the presented JWT, and the issuer returned from discovery.
+        """
+        pulumi.set(__self__, "audiences", audiences)
+        pulumi.set(__self__, "url", url)
+
+    @property
+    @pulumi.getter
+    def audiences(self) -> Sequence[builtins.str]:
+        """
+        The set of acceptable audiences the JWT must be issued to. At least one is required. When multiple is set, AudienceMatchPolicy is used in API Server configuration.
+        """
+        return pulumi.get(self, "audiences")
+
+    @property
+    @pulumi.getter
+    def url(self) -> builtins.str:
+        """
+        The issuer URL. The URL must begin with the scheme https and cannot contain a query string or fragment. This must match the "iss" claim in the presented JWT, and the issuer returned from discovery.
+        """
+        return pulumi.get(self, "url")
+
+
+@pulumi.output_type
+class JWTAuthenticatorPropertiesResponse(dict):
+    """
+    The properties of JWTAuthenticator. For details on how to configure the properties of a JWT authenticator, please refer to the Kubernetes documentation: https://kubernetes.io/docs/reference/access-authn-authz/authentication/#using-authentication-configuration. Please note that not all fields available in the Kubernetes documentation are supported by AKS. For troubleshooting, please see https://aka.ms/aks-external-issuers-docs.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "claimMappings":
+            suggest = "claim_mappings"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "claimValidationRules":
+            suggest = "claim_validation_rules"
+        elif key == "userValidationRules":
+            suggest = "user_validation_rules"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in JWTAuthenticatorPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        JWTAuthenticatorPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        JWTAuthenticatorPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 claim_mappings: 'outputs.JWTAuthenticatorClaimMappingsResponse',
+                 issuer: 'outputs.JWTAuthenticatorIssuerResponse',
+                 provisioning_state: builtins.str,
+                 claim_validation_rules: Optional[Sequence['outputs.JWTAuthenticatorValidationRuleResponse']] = None,
+                 user_validation_rules: Optional[Sequence['outputs.JWTAuthenticatorValidationRuleResponse']] = None):
+        """
+        The properties of JWTAuthenticator. For details on how to configure the properties of a JWT authenticator, please refer to the Kubernetes documentation: https://kubernetes.io/docs/reference/access-authn-authz/authentication/#using-authentication-configuration. Please note that not all fields available in the Kubernetes documentation are supported by AKS. For troubleshooting, please see https://aka.ms/aks-external-issuers-docs.
+        :param 'JWTAuthenticatorClaimMappingsResponse' claim_mappings: The mappings that define how user attributes are extracted from the token claims.
+        :param 'JWTAuthenticatorIssuerResponse' issuer: The JWT OIDC issuer details.
+        :param builtins.str provisioning_state: The current provisioning state of the JWT authenticator.
+        :param Sequence['JWTAuthenticatorValidationRuleResponse'] claim_validation_rules: The rules that are applied to validate token claims to authenticate users. All the expressions must evaluate to true for validation to succeed.
+        :param Sequence['JWTAuthenticatorValidationRuleResponse'] user_validation_rules: The rules that are applied to the mapped user before completing authentication. All the expressions must evaluate to true for validation to succeed.
+        """
+        pulumi.set(__self__, "claim_mappings", claim_mappings)
+        pulumi.set(__self__, "issuer", issuer)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if claim_validation_rules is not None:
+            pulumi.set(__self__, "claim_validation_rules", claim_validation_rules)
+        if user_validation_rules is not None:
+            pulumi.set(__self__, "user_validation_rules", user_validation_rules)
+
+    @property
+    @pulumi.getter(name="claimMappings")
+    def claim_mappings(self) -> 'outputs.JWTAuthenticatorClaimMappingsResponse':
+        """
+        The mappings that define how user attributes are extracted from the token claims.
+        """
+        return pulumi.get(self, "claim_mappings")
+
+    @property
+    @pulumi.getter
+    def issuer(self) -> 'outputs.JWTAuthenticatorIssuerResponse':
+        """
+        The JWT OIDC issuer details.
+        """
+        return pulumi.get(self, "issuer")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        The current provisioning state of the JWT authenticator.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="claimValidationRules")
+    def claim_validation_rules(self) -> Optional[Sequence['outputs.JWTAuthenticatorValidationRuleResponse']]:
+        """
+        The rules that are applied to validate token claims to authenticate users. All the expressions must evaluate to true for validation to succeed.
+        """
+        return pulumi.get(self, "claim_validation_rules")
+
+    @property
+    @pulumi.getter(name="userValidationRules")
+    def user_validation_rules(self) -> Optional[Sequence['outputs.JWTAuthenticatorValidationRuleResponse']]:
+        """
+        The rules that are applied to the mapped user before completing authentication. All the expressions must evaluate to true for validation to succeed.
+        """
+        return pulumi.get(self, "user_validation_rules")
+
+
+@pulumi.output_type
+class JWTAuthenticatorValidationRuleResponse(dict):
+    """
+    The validation rule for JWTAuthenticator.
+    """
+    def __init__(__self__, *,
+                 expression: builtins.str,
+                 message: Optional[builtins.str] = None):
+        """
+        The validation rule for JWTAuthenticator.
+        :param builtins.str expression: The CEL expression used to validate the claim or attribute.
+        :param builtins.str message: The validation error message.
+        """
+        pulumi.set(__self__, "expression", expression)
+        if message is not None:
+            pulumi.set(__self__, "message", message)
+
+    @property
+    @pulumi.getter
+    def expression(self) -> builtins.str:
+        """
+        The CEL expression used to validate the claim or attribute.
+        """
+        return pulumi.get(self, "expression")
+
+    @property
+    @pulumi.getter
+    def message(self) -> Optional[builtins.str]:
+        """
+        The validation error message.
+        """
+        return pulumi.get(self, "message")
+
+
 @pulumi.output_type
 class KubeletConfigResponse(dict):
     """
@@ -6654,6 +6950,197 @@ class NetworkProfileForSnapshotResponse(dict):
         return pulumi.get(self, "network_policy")
 
 
+@pulumi.output_type
+class NodeCustomizationPropertiesResponse(dict):
+    """
+    The properties of the Node Customization resource.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "containerImages":
+            suggest = "container_images"
+        elif key == "customizationScripts":
+            suggest = "customization_scripts"
+        elif key == "identityProfile":
+            suggest = "identity_profile"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodeCustomizationPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodeCustomizationPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodeCustomizationPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 provisioning_state: builtins.str,
+                 version: builtins.str,
+                 container_images: Optional[Sequence[builtins.str]] = None,
+                 customization_scripts: Optional[Sequence['outputs.NodeCustomizationScriptResponse']] = None,
+                 identity_profile: Optional['outputs.UserAssignedIdentityResponse'] = None):
+        """
+        The properties of the Node Customization resource.
+        :param builtins.str provisioning_state: The provisioning state of the node customization.
+        :param builtins.str version: An auto-generated value that changes when the other fields of the image customization are changed.
+        :param Sequence[builtins.str] container_images: The list of container images to cache on nodes. See https://kubernetes.io/docs/concepts/containers/images/#image-names
+        :param Sequence['NodeCustomizationScriptResponse'] customization_scripts: The scripts to customize the node before or after image capture.
+        :param 'UserAssignedIdentityResponse' identity_profile: The identity used to execute node customization tasks during image build time and provisioning time. 
+               If not specified the default agentpool identity will be used.
+               This does not affect provisioned nodes.
+        """
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "version", version)
+        if container_images is not None:
+            pulumi.set(__self__, "container_images", container_images)
+        if customization_scripts is not None:
+            pulumi.set(__self__, "customization_scripts", customization_scripts)
+        if identity_profile is not None:
+            pulumi.set(__self__, "identity_profile", identity_profile)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        The provisioning state of the node customization.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter
+    def version(self) -> builtins.str:
+        """
+        An auto-generated value that changes when the other fields of the image customization are changed.
+        """
+        return pulumi.get(self, "version")
+
+    @property
+    @pulumi.getter(name="containerImages")
+    def container_images(self) -> Optional[Sequence[builtins.str]]:
+        """
+        The list of container images to cache on nodes. See https://kubernetes.io/docs/concepts/containers/images/#image-names
+        """
+        return pulumi.get(self, "container_images")
+
+    @property
+    @pulumi.getter(name="customizationScripts")
+    def customization_scripts(self) -> Optional[Sequence['outputs.NodeCustomizationScriptResponse']]:
+        """
+        The scripts to customize the node before or after image capture.
+        """
+        return pulumi.get(self, "customization_scripts")
+
+    @property
+    @pulumi.getter(name="identityProfile")
+    def identity_profile(self) -> Optional['outputs.UserAssignedIdentityResponse']:
+        """
+        The identity used to execute node customization tasks during image build time and provisioning time. 
+        If not specified the default agentpool identity will be used.
+        This does not affect provisioned nodes.
+        """
+        return pulumi.get(self, "identity_profile")
+
+
+@pulumi.output_type
+class NodeCustomizationScriptResponse(dict):
+    """
+    Node customization script
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "executionPoint":
+            suggest = "execution_point"
+        elif key == "scriptType":
+            suggest = "script_type"
+        elif key == "rebootAfter":
+            suggest = "reboot_after"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodeCustomizationScriptResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodeCustomizationScriptResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodeCustomizationScriptResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 execution_point: builtins.str,
+                 name: builtins.str,
+                 script_type: builtins.str,
+                 reboot_after: Optional[builtins.bool] = None,
+                 script: Optional[builtins.str] = None):
+        """
+        Node customization script
+        :param builtins.str execution_point: The stage at which the script is executed.
+               Specifying `NodeImageBuildTime` will ensure changes are persisted into the node image.
+        :param builtins.str name: The name for the customization script. 
+               Must be unique within the node customization resource.
+               Can only contain lowercase alphanumeric,'-' or '.' characters.
+        :param builtins.str script_type: The runtime environment for the script (e.g. Bash).
+        :param builtins.bool reboot_after: Whether the node should reboot after successful script execution.
+        :param builtins.str script: The script content to be executed in plain text. Do not include secrets.
+        """
+        pulumi.set(__self__, "execution_point", execution_point)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "script_type", script_type)
+        if reboot_after is not None:
+            pulumi.set(__self__, "reboot_after", reboot_after)
+        if script is not None:
+            pulumi.set(__self__, "script", script)
+
+    @property
+    @pulumi.getter(name="executionPoint")
+    def execution_point(self) -> builtins.str:
+        """
+        The stage at which the script is executed.
+        Specifying `NodeImageBuildTime` will ensure changes are persisted into the node image.
+        """
+        return pulumi.get(self, "execution_point")
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        The name for the customization script. 
+        Must be unique within the node customization resource.
+        Can only contain lowercase alphanumeric,'-' or '.' characters.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="scriptType")
+    def script_type(self) -> builtins.str:
+        """
+        The runtime environment for the script (e.g. Bash).
+        """
+        return pulumi.get(self, "script_type")
+
+    @property
+    @pulumi.getter(name="rebootAfter")
+    def reboot_after(self) -> Optional[builtins.bool]:
+        """
+        Whether the node should reboot after successful script execution.
+        """
+        return pulumi.get(self, "reboot_after")
+
+    @property
+    @pulumi.getter
+    def script(self) -> Optional[builtins.str]:
+        """
+        The script content to be executed in plain text. Do not include secrets.
+        """
+        return pulumi.get(self, "script")
+
+
 @pulumi.output_type
 class NodeImageSelectionResponse(dict):
     """
@@ -8340,17 +8827,17 @@ class UpgradeOverrideSettingsResponse(dict):
 @pulumi.output_type
 class UserAssignedIdentityResponse(dict):
     """
-    Details about a user assigned identity.
+    User assigned identity properties
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
         if key == "clientId":
             suggest = "client_id"
-        elif key == "objectId":
-            suggest = "object_id"
         elif key == "principalId":
             suggest = "principal_id"
+        elif key == "objectId":
+            suggest = "object_id"
         elif key == "resourceId":
             suggest = "resource_id"
 
@@ -8366,49 +8853,47 @@ class UserAssignedIdentityResponse(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 client_id: Optional[builtins.str] = None,
+                 client_id: builtins.str,
+                 principal_id: builtins.str,
                  object_id: Optional[builtins.str] = None,
-                 principal_id: Optional[builtins.str] = None,
                  resource_id: Optional[builtins.str] = None):
         """
-        Details about a user assigned identity.
-        :param builtins.str client_id: The client ID of the user assigned identity.
-        :param builtins.str object_id: The object ID of the user assigned identity.
+        User assigned identity properties
+        :param builtins.str client_id: The client ID of the assigned identity.
         :param builtins.str principal_id: The principal ID of the assigned identity.
+        :param builtins.str object_id: The object ID of the user assigned identity.
         :param builtins.str resource_id: The resource ID of the user assigned identity.
         """
-        if client_id is not None:
-            pulumi.set(__self__, "client_id", client_id)
+        pulumi.set(__self__, "client_id", client_id)
+        pulumi.set(__self__, "principal_id", principal_id)
         if object_id is not None:
             pulumi.set(__self__, "object_id", object_id)
-        if principal_id is not None:
-            pulumi.set(__self__, "principal_id", principal_id)
         if resource_id is not None:
             pulumi.set(__self__, "resource_id", resource_id)
 
     @property
     @pulumi.getter(name="clientId")
-    def client_id(self) -> Optional[builtins.str]:
+    def client_id(self) -> builtins.str:
         """
-        The client ID of the user assigned identity.
+        The client ID of the assigned identity.
         """
         return pulumi.get(self, "client_id")
 
     @property
-    @pulumi.getter(name="objectId")
-    def object_id(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="principalId")
+    def principal_id(self) -> builtins.str:
         """
-        The object ID of the user assigned identity.
+        The principal ID of the assigned identity.
         """
-        return pulumi.get(self, "object_id")
+        return pulumi.get(self, "principal_id")
 
     @property
-    @pulumi.getter(name="principalId")
-    def principal_id(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="objectId")
+    def object_id(self) -> Optional[builtins.str]:
         """
-        The principal ID of the assigned identity.
+        The object ID of the user assigned identity.
         """
-        return pulumi.get(self, "principal_id")
+        return pulumi.get(self, "object_id")
 
     @property
     @pulumi.getter(name="resourceId")