pulumi-oci 2.13.0a1729198151__py3-none-any.whl → 2.14.0__py3-none-any.whl

pulumi_oci/__init__.py

@@ -123,8 +123,6 @@ if typing.TYPE_CHECKING:
     generativeai = __generativeai
     import pulumi_oci.genericartifactscontent as __genericartifactscontent
     genericartifactscontent = __genericartifactscontent
-    import pulumi_oci.globallydistributeddatabase as __globallydistributeddatabase
-    globallydistributeddatabase = __globallydistributeddatabase
     import pulumi_oci.goldengate as __goldengate
     goldengate = __goldengate
     import pulumi_oci.healthchecks as __healthchecks
@@ -311,7 +309,6 @@ else:
     fusionapps = _utilities.lazy_import('pulumi_oci.fusionapps')
     generativeai = _utilities.lazy_import('pulumi_oci.generativeai')
     genericartifactscontent = _utilities.lazy_import('pulumi_oci.genericartifactscontent')
-    globallydistributeddatabase = _utilities.lazy_import('pulumi_oci.globallydistributeddatabase')
     goldengate = _utilities.lazy_import('pulumi_oci.goldengate')
     healthchecks = _utilities.lazy_import('pulumi_oci.healthchecks')
     identity = _utilities.lazy_import('pulumi_oci.identity')
@@ -2084,6 +2081,14 @@ _utilities.register(
    "oci:DataSafe/discoveryMod:DiscoveryMod": "DiscoveryMod"
   }
  },
+ {
+  "pkg": "oci",
+  "mod": "DataSafe/generateOnPremConnectorConfiguration",
+  "fqn": "pulumi_oci.datasafe",
+  "classes": {
+   "oci:DataSafe/generateOnPremConnectorConfiguration:GenerateOnPremConnectorConfiguration": "GenerateOnPremConnectorConfiguration"
+  }
+ },
  {
   "pkg": "oci",
   "mod": "DataSafe/libraryMasingFormat",
@@ -3516,6 +3521,22 @@ _utilities.register(
    "oci:Dns/zone:Zone": "Zone"
   }
  },
+ {
+  "pkg": "oci",
+  "mod": "Dns/zonePromoteDnssecKeyVersion",
+  "fqn": "pulumi_oci.dns",
+  "classes": {
+   "oci:Dns/zonePromoteDnssecKeyVersion:ZonePromoteDnssecKeyVersion": "ZonePromoteDnssecKeyVersion"
+  }
+ },
+ {
+  "pkg": "oci",
+  "mod": "Dns/zoneStageDnssecKeyVersion",
+  "fqn": "pulumi_oci.dns",
+  "classes": {
+   "oci:Dns/zoneStageDnssecKeyVersion:ZoneStageDnssecKeyVersion": "ZoneStageDnssecKeyVersion"
+  }
+ },
  {
   "pkg": "oci",
   "mod": "Email/dkim",
@@ -3812,22 +3833,6 @@ _utilities.register(
    "oci:GenericArtifactsContent/artifactByPath:ArtifactByPath": "ArtifactByPath"
   }
  },
- {
-  "pkg": "oci",
-  "mod": "GloballyDistributedDatabase/privateEndpoint",
-  "fqn": "pulumi_oci.globallydistributeddatabase",
-  "classes": {
-   "oci:GloballyDistributedDatabase/privateEndpoint:PrivateEndpoint": "PrivateEndpoint"
-  }
- },
- {
-  "pkg": "oci",
-  "mod": "GloballyDistributedDatabase/shardedDatabase",
-  "fqn": "pulumi_oci.globallydistributeddatabase",
-  "classes": {
-   "oci:GloballyDistributedDatabase/shardedDatabase:ShardedDatabase": "ShardedDatabase"
-  }
- },
  {
   "pkg": "oci",
   "mod": "GoldenGate/connection",

pulumi_oci/containerengine/_inputs.py

@@ -39,6 +39,12 @@ __all__ = [
     'ClusterOptionsAdmissionControllerOptionsArgsDict',
     'ClusterOptionsKubernetesNetworkConfigArgs',
     'ClusterOptionsKubernetesNetworkConfigArgsDict',
+    'ClusterOptionsOpenIdConnectDiscoveryArgs',
+    'ClusterOptionsOpenIdConnectDiscoveryArgsDict',
+    'ClusterOptionsOpenIdConnectTokenAuthenticationConfigArgs',
+    'ClusterOptionsOpenIdConnectTokenAuthenticationConfigArgsDict',
+    'ClusterOptionsOpenIdConnectTokenAuthenticationConfigRequiredClaimArgs',
+    'ClusterOptionsOpenIdConnectTokenAuthenticationConfigRequiredClaimArgsDict',
     'ClusterOptionsPersistentVolumeConfigArgs',
     'ClusterOptionsPersistentVolumeConfigArgsDict',
     'ClusterOptionsServiceLbConfigArgs',
@@ -757,6 +763,14 @@ if not MYPY:
         """
         Network configuration for Kubernetes.
         """
+        open_id_connect_discovery: NotRequired[pulumi.Input['ClusterOptionsOpenIdConnectDiscoveryArgsDict']]
+        """
+        (Updatable) The property that define the status of the OIDC Discovery feature for a cluster.
+        """
+        open_id_connect_token_authentication_config: NotRequired[pulumi.Input['ClusterOptionsOpenIdConnectTokenAuthenticationConfigArgsDict']]
+        """
+        (Updatable) The properties that configure OIDC token authentication in kube-apiserver. For more information, see [Configuring the API Server](https://kubernetes.io/docs/reference/access-authn-authz/authentication/#using-flags).
+        """
         persistent_volume_config: NotRequired[pulumi.Input['ClusterOptionsPersistentVolumeConfigArgsDict']]
         """
         (Updatable) Configuration to be applied to block volumes created by Kubernetes Persistent Volume Claims (PVC)
@@ -778,6 +792,8 @@ class ClusterOptionsArgs:
                  add_ons: Optional[pulumi.Input['ClusterOptionsAddOnsArgs']] = None,
                  admission_controller_options: Optional[pulumi.Input['ClusterOptionsAdmissionControllerOptionsArgs']] = None,
                  kubernetes_network_config: Optional[pulumi.Input['ClusterOptionsKubernetesNetworkConfigArgs']] = None,
+                 open_id_connect_discovery: Optional[pulumi.Input['ClusterOptionsOpenIdConnectDiscoveryArgs']] = None,
+                 open_id_connect_token_authentication_config: Optional[pulumi.Input['ClusterOptionsOpenIdConnectTokenAuthenticationConfigArgs']] = None,
                  persistent_volume_config: Optional[pulumi.Input['ClusterOptionsPersistentVolumeConfigArgs']] = None,
                  service_lb_config: Optional[pulumi.Input['ClusterOptionsServiceLbConfigArgs']] = None,
                  service_lb_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
@@ -785,6 +801,8 @@ class ClusterOptionsArgs:
         :param pulumi.Input['ClusterOptionsAddOnsArgs'] add_ons: Configurable cluster add-ons
         :param pulumi.Input['ClusterOptionsAdmissionControllerOptionsArgs'] admission_controller_options: (Updatable) Configurable cluster admission controllers
         :param pulumi.Input['ClusterOptionsKubernetesNetworkConfigArgs'] kubernetes_network_config: Network configuration for Kubernetes.
+        :param pulumi.Input['ClusterOptionsOpenIdConnectDiscoveryArgs'] open_id_connect_discovery: (Updatable) The property that define the status of the OIDC Discovery feature for a cluster.
+        :param pulumi.Input['ClusterOptionsOpenIdConnectTokenAuthenticationConfigArgs'] open_id_connect_token_authentication_config: (Updatable) The properties that configure OIDC token authentication in kube-apiserver. For more information, see [Configuring the API Server](https://kubernetes.io/docs/reference/access-authn-authz/authentication/#using-flags).
         :param pulumi.Input['ClusterOptionsPersistentVolumeConfigArgs'] persistent_volume_config: (Updatable) Configuration to be applied to block volumes created by Kubernetes Persistent Volume Claims (PVC)
         :param pulumi.Input['ClusterOptionsServiceLbConfigArgs'] service_lb_config: (Updatable) Configuration to be applied to load balancers created by Kubernetes services
         :param pulumi.Input[Sequence[pulumi.Input[str]]] service_lb_subnet_ids: The OCIDs of the subnets used for Kubernetes services load balancers.
@@ -795,6 +813,10 @@ class ClusterOptionsArgs:
             pulumi.set(__self__, "admission_controller_options", admission_controller_options)
         if kubernetes_network_config is not None:
             pulumi.set(__self__, "kubernetes_network_config", kubernetes_network_config)
+        if open_id_connect_discovery is not None:
+            pulumi.set(__self__, "open_id_connect_discovery", open_id_connect_discovery)
+        if open_id_connect_token_authentication_config is not None:
+            pulumi.set(__self__, "open_id_connect_token_authentication_config", open_id_connect_token_authentication_config)
         if persistent_volume_config is not None:
             pulumi.set(__self__, "persistent_volume_config", persistent_volume_config)
         if service_lb_config is not None:
@@ -838,6 +860,30 @@ class ClusterOptionsArgs:
     def kubernetes_network_config(self, value: Optional[pulumi.Input['ClusterOptionsKubernetesNetworkConfigArgs']]):
         pulumi.set(self, "kubernetes_network_config", value)
 
+    @property
+    @pulumi.getter(name="openIdConnectDiscovery")
+    def open_id_connect_discovery(self) -> Optional[pulumi.Input['ClusterOptionsOpenIdConnectDiscoveryArgs']]:
+        """
+        (Updatable) The property that define the status of the OIDC Discovery feature for a cluster.
+        """
+        return pulumi.get(self, "open_id_connect_discovery")
+
+    @open_id_connect_discovery.setter
+    def open_id_connect_discovery(self, value: Optional[pulumi.Input['ClusterOptionsOpenIdConnectDiscoveryArgs']]):
+        pulumi.set(self, "open_id_connect_discovery", value)
+
+    @property
+    @pulumi.getter(name="openIdConnectTokenAuthenticationConfig")
+    def open_id_connect_token_authentication_config(self) -> Optional[pulumi.Input['ClusterOptionsOpenIdConnectTokenAuthenticationConfigArgs']]:
+        """
+        (Updatable) The properties that configure OIDC token authentication in kube-apiserver. For more information, see [Configuring the API Server](https://kubernetes.io/docs/reference/access-authn-authz/authentication/#using-flags).
+        """
+        return pulumi.get(self, "open_id_connect_token_authentication_config")
+
+    @open_id_connect_token_authentication_config.setter
+    def open_id_connect_token_authentication_config(self, value: Optional[pulumi.Input['ClusterOptionsOpenIdConnectTokenAuthenticationConfigArgs']]):
+        pulumi.set(self, "open_id_connect_token_authentication_config", value)
+
     @property
     @pulumi.getter(name="persistentVolumeConfig")
     def persistent_volume_config(self) -> Optional[pulumi.Input['ClusterOptionsPersistentVolumeConfigArgs']]:
@@ -1011,6 +1057,301 @@ class ClusterOptionsKubernetesNetworkConfigArgs:
         pulumi.set(self, "services_cidr", value)
 
 
+if not MYPY:
+    class ClusterOptionsOpenIdConnectDiscoveryArgsDict(TypedDict):
+        is_open_id_connect_discovery_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        (Updatable) Whether the cluster has OIDC Discovery enabled. Defaults to false. If set to true, the cluster will be assigned a public OIDC Discovery endpoint.
+        """
+elif False:
+    ClusterOptionsOpenIdConnectDiscoveryArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ClusterOptionsOpenIdConnectDiscoveryArgs:
+    def __init__(__self__, *,
+                 is_open_id_connect_discovery_enabled: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[bool] is_open_id_connect_discovery_enabled: (Updatable) Whether the cluster has OIDC Discovery enabled. Defaults to false. If set to true, the cluster will be assigned a public OIDC Discovery endpoint.
+        """
+        if is_open_id_connect_discovery_enabled is not None:
+            pulumi.set(__self__, "is_open_id_connect_discovery_enabled", is_open_id_connect_discovery_enabled)
+
+    @property
+    @pulumi.getter(name="isOpenIdConnectDiscoveryEnabled")
+    def is_open_id_connect_discovery_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        (Updatable) Whether the cluster has OIDC Discovery enabled. Defaults to false. If set to true, the cluster will be assigned a public OIDC Discovery endpoint.
+        """
+        return pulumi.get(self, "is_open_id_connect_discovery_enabled")
+
+    @is_open_id_connect_discovery_enabled.setter
+    def is_open_id_connect_discovery_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_open_id_connect_discovery_enabled", value)
+
+
+if not MYPY:
+    class ClusterOptionsOpenIdConnectTokenAuthenticationConfigArgsDict(TypedDict):
+        is_open_id_connect_auth_enabled: pulumi.Input[bool]
+        """
+        (Updatable) Whether the cluster has OIDC Auth Config enabled. Defaults to false.
+        """
+        ca_certificate: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) A Base64 encoded public RSA or ECDSA certificates used to signed your identity provider's web certificate.
+        """
+        client_id: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) A client id that all tokens must be issued for.
+        """
+        groups_claim: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) JWT claim to use as the user's group. If the claim is present it must be an array of strings.
+        """
+        groups_prefix: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Prefix prepended to group claims to prevent clashes with existing names (such as system:groups).
+        """
+        issuer_url: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) URL of the provider that allows the API server to discover public signing keys.  Only URLs that use the https:// scheme are accepted. This is typically the provider's discovery URL,  changed to have an empty path.
+        """
+        required_claims: NotRequired[pulumi.Input[Sequence[pulumi.Input['ClusterOptionsOpenIdConnectTokenAuthenticationConfigRequiredClaimArgsDict']]]]
+        """
+        (Updatable) A key=value pair that describes a required claim in the ID Token. If set, the claim is verified to be present  in the ID Token with a matching value. Repeat this flag to specify multiple claims.
+        """
+        signing_algorithms: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        (Updatable) The signing algorithms accepted. Default is ["RS256"].
+        """
+        username_claim: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) JWT claim to use as the user name. By default sub, which is expected to be a unique identifier of the end  user. Admins can choose other claims, such as email or name, depending on their provider. However, claims  other than email will be prefixed with the issuer URL to prevent naming clashes with other plugins.
+        """
+        username_prefix: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) Prefix prepended to username claims to prevent clashes with existing names (such as system:users).  For example, the value oidc: will create usernames like oidc:jane.doe. If this flag isn't provided and  --oidc-username-claim is a value other than email the prefix defaults to ( Issuer URL )# where  ( Issuer URL ) is the value of --oidc-issuer-url. The value - can be used to disable all prefixing.
+        """
+elif False:
+    ClusterOptionsOpenIdConnectTokenAuthenticationConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ClusterOptionsOpenIdConnectTokenAuthenticationConfigArgs:
+    def __init__(__self__, *,
+                 is_open_id_connect_auth_enabled: pulumi.Input[bool],
+                 ca_certificate: Optional[pulumi.Input[str]] = None,
+                 client_id: Optional[pulumi.Input[str]] = None,
+                 groups_claim: Optional[pulumi.Input[str]] = None,
+                 groups_prefix: Optional[pulumi.Input[str]] = None,
+                 issuer_url: Optional[pulumi.Input[str]] = None,
+                 required_claims: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterOptionsOpenIdConnectTokenAuthenticationConfigRequiredClaimArgs']]]] = None,
+                 signing_algorithms: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 username_claim: Optional[pulumi.Input[str]] = None,
+                 username_prefix: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[bool] is_open_id_connect_auth_enabled: (Updatable) Whether the cluster has OIDC Auth Config enabled. Defaults to false.
+        :param pulumi.Input[str] ca_certificate: (Updatable) A Base64 encoded public RSA or ECDSA certificates used to signed your identity provider's web certificate.
+        :param pulumi.Input[str] client_id: (Updatable) A client id that all tokens must be issued for.
+        :param pulumi.Input[str] groups_claim: (Updatable) JWT claim to use as the user's group. If the claim is present it must be an array of strings.
+        :param pulumi.Input[str] groups_prefix: (Updatable) Prefix prepended to group claims to prevent clashes with existing names (such as system:groups).
+        :param pulumi.Input[str] issuer_url: (Updatable) URL of the provider that allows the API server to discover public signing keys.  Only URLs that use the https:// scheme are accepted. This is typically the provider's discovery URL,  changed to have an empty path.
+        :param pulumi.Input[Sequence[pulumi.Input['ClusterOptionsOpenIdConnectTokenAuthenticationConfigRequiredClaimArgs']]] required_claims: (Updatable) A key=value pair that describes a required claim in the ID Token. If set, the claim is verified to be present  in the ID Token with a matching value. Repeat this flag to specify multiple claims.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] signing_algorithms: (Updatable) The signing algorithms accepted. Default is ["RS256"].
+        :param pulumi.Input[str] username_claim: (Updatable) JWT claim to use as the user name. By default sub, which is expected to be a unique identifier of the end  user. Admins can choose other claims, such as email or name, depending on their provider. However, claims  other than email will be prefixed with the issuer URL to prevent naming clashes with other plugins.
+        :param pulumi.Input[str] username_prefix: (Updatable) Prefix prepended to username claims to prevent clashes with existing names (such as system:users).  For example, the value oidc: will create usernames like oidc:jane.doe. If this flag isn't provided and  --oidc-username-claim is a value other than email the prefix defaults to ( Issuer URL )# where  ( Issuer URL ) is the value of --oidc-issuer-url. The value - can be used to disable all prefixing.
+        """
+        pulumi.set(__self__, "is_open_id_connect_auth_enabled", is_open_id_connect_auth_enabled)
+        if ca_certificate is not None:
+            pulumi.set(__self__, "ca_certificate", ca_certificate)
+        if client_id is not None:
+            pulumi.set(__self__, "client_id", client_id)
+        if groups_claim is not None:
+            pulumi.set(__self__, "groups_claim", groups_claim)
+        if groups_prefix is not None:
+            pulumi.set(__self__, "groups_prefix", groups_prefix)
+        if issuer_url is not None:
+            pulumi.set(__self__, "issuer_url", issuer_url)
+        if required_claims is not None:
+            pulumi.set(__self__, "required_claims", required_claims)
+        if signing_algorithms is not None:
+            pulumi.set(__self__, "signing_algorithms", signing_algorithms)
+        if username_claim is not None:
+            pulumi.set(__self__, "username_claim", username_claim)
+        if username_prefix is not None:
+            pulumi.set(__self__, "username_prefix", username_prefix)
+
+    @property
+    @pulumi.getter(name="isOpenIdConnectAuthEnabled")
+    def is_open_id_connect_auth_enabled(self) -> pulumi.Input[bool]:
+        """
+        (Updatable) Whether the cluster has OIDC Auth Config enabled. Defaults to false.
+        """
+        return pulumi.get(self, "is_open_id_connect_auth_enabled")
+
+    @is_open_id_connect_auth_enabled.setter
+    def is_open_id_connect_auth_enabled(self, value: pulumi.Input[bool]):
+        pulumi.set(self, "is_open_id_connect_auth_enabled", value)
+
+    @property
+    @pulumi.getter(name="caCertificate")
+    def ca_certificate(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) A Base64 encoded public RSA or ECDSA certificates used to signed your identity provider's web certificate.
+        """
+        return pulumi.get(self, "ca_certificate")
+
+    @ca_certificate.setter
+    def ca_certificate(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "ca_certificate", value)
+
+    @property
+    @pulumi.getter(name="clientId")
+    def client_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) A client id that all tokens must be issued for.
+        """
+        return pulumi.get(self, "client_id")
+
+    @client_id.setter
+    def client_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "client_id", value)
+
+    @property
+    @pulumi.getter(name="groupsClaim")
+    def groups_claim(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) JWT claim to use as the user's group. If the claim is present it must be an array of strings.
+        """
+        return pulumi.get(self, "groups_claim")
+
+    @groups_claim.setter
+    def groups_claim(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "groups_claim", value)
+
+    @property
+    @pulumi.getter(name="groupsPrefix")
+    def groups_prefix(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) Prefix prepended to group claims to prevent clashes with existing names (such as system:groups).
+        """
+        return pulumi.get(self, "groups_prefix")
+
+    @groups_prefix.setter
+    def groups_prefix(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "groups_prefix", value)
+
+    @property
+    @pulumi.getter(name="issuerUrl")
+    def issuer_url(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) URL of the provider that allows the API server to discover public signing keys.  Only URLs that use the https:// scheme are accepted. This is typically the provider's discovery URL,  changed to have an empty path.
+        """
+        return pulumi.get(self, "issuer_url")
+
+    @issuer_url.setter
+    def issuer_url(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "issuer_url", value)
+
+    @property
+    @pulumi.getter(name="requiredClaims")
+    def required_claims(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterOptionsOpenIdConnectTokenAuthenticationConfigRequiredClaimArgs']]]]:
+        """
+        (Updatable) A key=value pair that describes a required claim in the ID Token. If set, the claim is verified to be present  in the ID Token with a matching value. Repeat this flag to specify multiple claims.
+        """
+        return pulumi.get(self, "required_claims")
+
+    @required_claims.setter
+    def required_claims(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterOptionsOpenIdConnectTokenAuthenticationConfigRequiredClaimArgs']]]]):
+        pulumi.set(self, "required_claims", value)
+
+    @property
+    @pulumi.getter(name="signingAlgorithms")
+    def signing_algorithms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        (Updatable) The signing algorithms accepted. Default is ["RS256"].
+        """
+        return pulumi.get(self, "signing_algorithms")
+
+    @signing_algorithms.setter
+    def signing_algorithms(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "signing_algorithms", value)
+
+    @property
+    @pulumi.getter(name="usernameClaim")
+    def username_claim(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) JWT claim to use as the user name. By default sub, which is expected to be a unique identifier of the end  user. Admins can choose other claims, such as email or name, depending on their provider. However, claims  other than email will be prefixed with the issuer URL to prevent naming clashes with other plugins.
+        """
+        return pulumi.get(self, "username_claim")
+
+    @username_claim.setter
+    def username_claim(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "username_claim", value)
+
+    @property
+    @pulumi.getter(name="usernamePrefix")
+    def username_prefix(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) Prefix prepended to username claims to prevent clashes with existing names (such as system:users).  For example, the value oidc: will create usernames like oidc:jane.doe. If this flag isn't provided and  --oidc-username-claim is a value other than email the prefix defaults to ( Issuer URL )# where  ( Issuer URL ) is the value of --oidc-issuer-url. The value - can be used to disable all prefixing.
+        """
+        return pulumi.get(self, "username_prefix")
+
+    @username_prefix.setter
+    def username_prefix(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "username_prefix", value)
+
+
+if not MYPY:
+    class ClusterOptionsOpenIdConnectTokenAuthenticationConfigRequiredClaimArgsDict(TypedDict):
+        key: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) The key of the pair.
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) The value of the pair.
+        """
+elif False:
+    ClusterOptionsOpenIdConnectTokenAuthenticationConfigRequiredClaimArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ClusterOptionsOpenIdConnectTokenAuthenticationConfigRequiredClaimArgs:
+    def __init__(__self__, *,
+                 key: Optional[pulumi.Input[str]] = None,
+                 value: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] key: (Updatable) The key of the pair.
+        :param pulumi.Input[str] value: (Updatable) The value of the pair.
+        """
+        if key is not None:
+            pulumi.set(__self__, "key", key)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def key(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) The key of the pair.
+        """
+        return pulumi.get(self, "key")
+
+    @key.setter
+    def key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "key", value)
+
+    @property
+    @pulumi.getter
+    def value(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) The value of the pair.
+        """
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "value", value)
+
+
 if not MYPY:
     class ClusterOptionsPersistentVolumeConfigArgsDict(TypedDict):
         defined_tags: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]

pulumi_oci/containerengine/cluster.py

@@ -239,6 +239,7 @@ class _ClusterState:
                  lifecycle_details: Optional[pulumi.Input[str]] = None,
                  metadatas: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterMetadataArgs']]]] = None,
                  name: Optional[pulumi.Input[str]] = None,
+                 open_id_connect_discovery_endpoint: Optional[pulumi.Input[str]] = None,
                  options: Optional[pulumi.Input['ClusterOptionsArgs']] = None,
                  state: Optional[pulumi.Input[str]] = None,
                  type: Optional[pulumi.Input[str]] = None,
@@ -258,6 +259,7 @@ class _ClusterState:
         :param pulumi.Input[str] lifecycle_details: Details about the state of the cluster masters.
         :param pulumi.Input[Sequence[pulumi.Input['ClusterMetadataArgs']]] metadatas: Metadata about the cluster.
         :param pulumi.Input[str] name: (Updatable) The name of the cluster. Avoid entering confidential information.
+        :param pulumi.Input[str] open_id_connect_discovery_endpoint: The cluster-specific OpenID Connect Discovery endpoint
         :param pulumi.Input['ClusterOptionsArgs'] options: (Updatable) Optional attributes for the cluster.
         :param pulumi.Input[str] state: The state of the cluster masters.
         :param pulumi.Input[str] type: (Updatable) Type of cluster
@@ -293,6 +295,8 @@ class _ClusterState:
             pulumi.set(__self__, "metadatas", metadatas)
         if name is not None:
             pulumi.set(__self__, "name", name)
+        if open_id_connect_discovery_endpoint is not None:
+            pulumi.set(__self__, "open_id_connect_discovery_endpoint", open_id_connect_discovery_endpoint)
         if options is not None:
             pulumi.set(__self__, "options", options)
         if state is not None:
@@ -458,6 +462,18 @@ class _ClusterState:
     def name(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "name", value)
 
+    @property
+    @pulumi.getter(name="openIdConnectDiscoveryEndpoint")
+    def open_id_connect_discovery_endpoint(self) -> Optional[pulumi.Input[str]]:
+        """
+        The cluster-specific OpenID Connect Discovery endpoint
+        """
+        return pulumi.get(self, "open_id_connect_discovery_endpoint")
+
+    @open_id_connect_discovery_endpoint.setter
+    def open_id_connect_discovery_endpoint(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "open_id_connect_discovery_endpoint", value)
+
     @property
     @pulumi.getter
     def options(self) -> Optional[pulumi.Input['ClusterOptionsArgs']]:
@@ -578,6 +594,24 @@ class Cluster(pulumi.CustomResource):
                     "pods_cidr": cluster_options_kubernetes_network_config_pods_cidr,
                     "services_cidr": cluster_options_kubernetes_network_config_services_cidr,
                 },
+                "open_id_connect_token_authentication_config": {
+                    "is_open_id_connect_auth_enabled": cluster_options_open_id_connect_token_authentication_config_is_open_id_connect_auth_enabled,
+                    "ca_certificate": cluster_options_open_id_connect_token_authentication_config_ca_certificate,
+                    "client_id": test_client["id"],
+                    "groups_claim": cluster_options_open_id_connect_token_authentication_config_groups_claim,
+                    "groups_prefix": cluster_options_open_id_connect_token_authentication_config_groups_prefix,
+                    "issuer_url": cluster_options_open_id_connect_token_authentication_config_issuer_url,
+                    "required_claims": [{
+                        "key": cluster_options_open_id_connect_token_authentication_config_required_claims_key,
+                        "value": cluster_options_open_id_connect_token_authentication_config_required_claims_value,
+                    }],
+                    "signing_algorithms": cluster_options_open_id_connect_token_authentication_config_signing_algorithms,
+                    "username_claim": cluster_options_open_id_connect_token_authentication_config_username_claim,
+                    "username_prefix": cluster_options_open_id_connect_token_authentication_config_username_prefix,
+                },
+                "open_id_connect_discovery": {
+                    "is_open_id_connect_discovery_enabled": cluster_options_open_id_connect_discovery_is_open_id_connect_discovery_enabled,
+                },
                 "persistent_volume_config": {
                     "defined_tags": {
                         "operations__cost_center": "42",
@@ -681,6 +715,24 @@ class Cluster(pulumi.CustomResource):
                     "pods_cidr": cluster_options_kubernetes_network_config_pods_cidr,
                     "services_cidr": cluster_options_kubernetes_network_config_services_cidr,
                 },
+                "open_id_connect_token_authentication_config": {
+                    "is_open_id_connect_auth_enabled": cluster_options_open_id_connect_token_authentication_config_is_open_id_connect_auth_enabled,
+                    "ca_certificate": cluster_options_open_id_connect_token_authentication_config_ca_certificate,
+                    "client_id": test_client["id"],
+                    "groups_claim": cluster_options_open_id_connect_token_authentication_config_groups_claim,
+                    "groups_prefix": cluster_options_open_id_connect_token_authentication_config_groups_prefix,
+                    "issuer_url": cluster_options_open_id_connect_token_authentication_config_issuer_url,
+                    "required_claims": [{
+                        "key": cluster_options_open_id_connect_token_authentication_config_required_claims_key,
+                        "value": cluster_options_open_id_connect_token_authentication_config_required_claims_value,
+                    }],
+                    "signing_algorithms": cluster_options_open_id_connect_token_authentication_config_signing_algorithms,
+                    "username_claim": cluster_options_open_id_connect_token_authentication_config_username_claim,
+                    "username_prefix": cluster_options_open_id_connect_token_authentication_config_username_prefix,
+                },
+                "open_id_connect_discovery": {
+                    "is_open_id_connect_discovery_enabled": cluster_options_open_id_connect_discovery_is_open_id_connect_discovery_enabled,
+                },
                 "persistent_volume_config": {
                     "defined_tags": {
                         "operations__cost_center": "42",
@@ -768,6 +820,7 @@ class Cluster(pulumi.CustomResource):
             __props__.__dict__["endpoints"] = None
             __props__.__dict__["lifecycle_details"] = None
             __props__.__dict__["metadatas"] = None
+            __props__.__dict__["open_id_connect_discovery_endpoint"] = None
             __props__.__dict__["state"] = None
         super(Cluster, __self__).__init__(
             'oci:ContainerEngine/cluster:Cluster',
@@ -792,6 +845,7 @@ class Cluster(pulumi.CustomResource):
             lifecycle_details: Optional[pulumi.Input[str]] = None,
             metadatas: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ClusterMetadataArgs', 'ClusterMetadataArgsDict']]]]] = None,
             name: Optional[pulumi.Input[str]] = None,
+            open_id_connect_discovery_endpoint: Optional[pulumi.Input[str]] = None,
             options: Optional[pulumi.Input[Union['ClusterOptionsArgs', 'ClusterOptionsArgsDict']]] = None,
             state: Optional[pulumi.Input[str]] = None,
             type: Optional[pulumi.Input[str]] = None,
@@ -816,6 +870,7 @@ class Cluster(pulumi.CustomResource):
         :param pulumi.Input[str] lifecycle_details: Details about the state of the cluster masters.
         :param pulumi.Input[Sequence[pulumi.Input[Union['ClusterMetadataArgs', 'ClusterMetadataArgsDict']]]] metadatas: Metadata about the cluster.
         :param pulumi.Input[str] name: (Updatable) The name of the cluster. Avoid entering confidential information.
+        :param pulumi.Input[str] open_id_connect_discovery_endpoint: The cluster-specific OpenID Connect Discovery endpoint
         :param pulumi.Input[Union['ClusterOptionsArgs', 'ClusterOptionsArgsDict']] options: (Updatable) Optional attributes for the cluster.
         :param pulumi.Input[str] state: The state of the cluster masters.
         :param pulumi.Input[str] type: (Updatable) Type of cluster
@@ -842,6 +897,7 @@ class Cluster(pulumi.CustomResource):
         __props__.__dict__["lifecycle_details"] = lifecycle_details
         __props__.__dict__["metadatas"] = metadatas
         __props__.__dict__["name"] = name
+        __props__.__dict__["open_id_connect_discovery_endpoint"] = open_id_connect_discovery_endpoint
         __props__.__dict__["options"] = options
         __props__.__dict__["state"] = state
         __props__.__dict__["type"] = type
@@ -952,6 +1008,14 @@ class Cluster(pulumi.CustomResource):
         """
         return pulumi.get(self, "name")
 
+    @property
+    @pulumi.getter(name="openIdConnectDiscoveryEndpoint")
+    def open_id_connect_discovery_endpoint(self) -> pulumi.Output[str]:
+        """
+        The cluster-specific OpenID Connect Discovery endpoint
+        """
+        return pulumi.get(self, "open_id_connect_discovery_endpoint")
+
     @property
     @pulumi.getter
     def options(self) -> pulumi.Output['outputs.ClusterOptions']:

pulumi_oci/containerengine/get_cluster.py

@@ -27,7 +27,7 @@ class GetClusterResult:
     """
     A collection of values returned by getCluster.
     """
-    def __init__(__self__, available_kubernetes_upgrades=None, cluster_id=None, cluster_pod_network_options=None, compartment_id=None, defined_tags=None, endpoint_configs=None, endpoints=None, freeform_tags=None, id=None, image_policy_configs=None, kms_key_id=None, kubernetes_version=None, lifecycle_details=None, metadatas=None, name=None, options=None, state=None, type=None, vcn_id=None):
+    def __init__(__self__, available_kubernetes_upgrades=None, cluster_id=None, cluster_pod_network_options=None, compartment_id=None, defined_tags=None, endpoint_configs=None, endpoints=None, freeform_tags=None, id=None, image_policy_configs=None, kms_key_id=None, kubernetes_version=None, lifecycle_details=None, metadatas=None, name=None, open_id_connect_discovery_endpoint=None, options=None, state=None, type=None, vcn_id=None):
         if available_kubernetes_upgrades and not isinstance(available_kubernetes_upgrades, list):
             raise TypeError("Expected argument 'available_kubernetes_upgrades' to be a list")
         pulumi.set(__self__, "available_kubernetes_upgrades", available_kubernetes_upgrades)
@@ -73,6 +73,9 @@ class GetClusterResult:
         if name and not isinstance(name, str):
             raise TypeError("Expected argument 'name' to be a str")
         pulumi.set(__self__, "name", name)
+        if open_id_connect_discovery_endpoint and not isinstance(open_id_connect_discovery_endpoint, str):
+            raise TypeError("Expected argument 'open_id_connect_discovery_endpoint' to be a str")
+        pulumi.set(__self__, "open_id_connect_discovery_endpoint", open_id_connect_discovery_endpoint)
         if options and not isinstance(options, list):
             raise TypeError("Expected argument 'options' to be a list")
         pulumi.set(__self__, "options", options)
@@ -203,6 +206,11 @@ class GetClusterResult:
         """
         return pulumi.get(self, "name")
 
+    @property
+    @pulumi.getter(name="openIdConnectDiscoveryEndpoint")
+    def open_id_connect_discovery_endpoint(self) -> str:
+        return pulumi.get(self, "open_id_connect_discovery_endpoint")
+
     @property
     @pulumi.getter
     def options(self) -> Sequence['outputs.GetClusterOptionResult']:
@@ -257,6 +265,7 @@ class AwaitableGetClusterResult(GetClusterResult):
             lifecycle_details=self.lifecycle_details,
             metadatas=self.metadatas,
             name=self.name,
+            open_id_connect_discovery_endpoint=self.open_id_connect_discovery_endpoint,
             options=self.options,
             state=self.state,
             type=self.type,
@@ -303,6 +312,7 @@ def get_cluster(cluster_id: Optional[str] = None,
         lifecycle_details=pulumi.get(__ret__, 'lifecycle_details'),
         metadatas=pulumi.get(__ret__, 'metadatas'),
         name=pulumi.get(__ret__, 'name'),
+        open_id_connect_discovery_endpoint=pulumi.get(__ret__, 'open_id_connect_discovery_endpoint'),
         options=pulumi.get(__ret__, 'options'),
         state=pulumi.get(__ret__, 'state'),
         type=pulumi.get(__ret__, 'type'),
@@ -346,6 +356,7 @@ def get_cluster_output(cluster_id: Optional[pulumi.Input[str]] = None,
         lifecycle_details=pulumi.get(__response__, 'lifecycle_details'),
         metadatas=pulumi.get(__response__, 'metadatas'),
         name=pulumi.get(__response__, 'name'),
+        open_id_connect_discovery_endpoint=pulumi.get(__response__, 'open_id_connect_discovery_endpoint'),
         options=pulumi.get(__response__, 'options'),
         state=pulumi.get(__response__, 'state'),
         type=pulumi.get(__response__, 'type'),