pulumi-azure-native 2.72.0a1731506636__py3-none-any.whl → 2.73.0a1732101729__py3-none-any.whl

pulumi_azure_native/batch/v20240701/_inputs.py

@@ -1832,7 +1832,7 @@ if not MYPY:
     class InboundNatPoolArgsDict(TypedDict):
         backend_port: pulumi.Input[int]
         """
-        This must be unique within a Batch pool. Acceptable values are between 1 and 65535 except for 22, 3389, 29876 and 29877 as these are reserved. If any reserved values are provided the request fails with HTTP status code 400.
+        This must be unique within a Batch pool. Acceptable values are between 1 and 65535 except for 29876 and 29877 as these are reserved. If any reserved values are provided the request fails with HTTP status code 400.
         """
         frontend_port_range_end: pulumi.Input[int]
         """
@@ -1864,7 +1864,7 @@ class InboundNatPoolArgs:
                  protocol: pulumi.Input['InboundEndpointProtocol'],
                  network_security_group_rules: Optional[pulumi.Input[Sequence[pulumi.Input['NetworkSecurityGroupRuleArgs']]]] = None):
         """
-        :param pulumi.Input[int] backend_port: This must be unique within a Batch pool. Acceptable values are between 1 and 65535 except for 22, 3389, 29876 and 29877 as these are reserved. If any reserved values are provided the request fails with HTTP status code 400.
+        :param pulumi.Input[int] backend_port: This must be unique within a Batch pool. Acceptable values are between 1 and 65535 except for 29876 and 29877 as these are reserved. If any reserved values are provided the request fails with HTTP status code 400.
         :param pulumi.Input[int] frontend_port_range_end: Acceptable values range between 1 and 65534 except ports from 50000 to 55000 which are reserved by the Batch service. All ranges within a pool must be distinct and cannot overlap. If any reserved or overlapping values are provided the request fails with HTTP status code 400.
         :param pulumi.Input[int] frontend_port_range_start: Acceptable values range between 1 and 65534 except ports from 50000 to 55000 which are reserved. All ranges within a pool must be distinct and cannot overlap. If any reserved or overlapping values are provided the request fails with HTTP status code 400.
         :param pulumi.Input[str] name: The name must be unique within a Batch pool, can contain letters, numbers, underscores, periods, and hyphens. Names must start with a letter or number, must end with a letter, number, or underscore, and cannot exceed 77 characters.  If any invalid values are provided the request fails with HTTP status code 400.
@@ -1882,7 +1882,7 @@ class InboundNatPoolArgs:
     @pulumi.getter(name="backendPort")
     def backend_port(self) -> pulumi.Input[int]:
         """
-        This must be unique within a Batch pool. Acceptable values are between 1 and 65535 except for 22, 3389, 29876 and 29877 as these are reserved. If any reserved values are provided the request fails with HTTP status code 400.
+        This must be unique within a Batch pool. Acceptable values are between 1 and 65535 except for 29876 and 29877 as these are reserved. If any reserved values are provided the request fails with HTTP status code 400.
         """
         return pulumi.get(self, "backend_port")
 
@@ -2379,7 +2379,7 @@ if not MYPY:
         """
         subnet_id: NotRequired[pulumi.Input[str]]
         """
-        The virtual network must be in the same region and subscription as the Azure Batch account. The specified subnet should have enough free IP addresses to accommodate the number of nodes in the pool. If the subnet doesn't have enough free IP addresses, the pool will partially allocate compute nodes and a resize error will occur. The 'MicrosoftAzureBatch' service principal must have the 'Classic Virtual Machine Contributor' Role-Based Access Control (RBAC) role for the specified VNet. The specified subnet must allow communication from the Azure Batch service to be able to schedule tasks on the compute nodes. This can be verified by checking if the specified VNet has any associated Network Security Groups (NSG). If communication to the compute nodes in the specified subnet is denied by an NSG, then the Batch service will set the state of the compute nodes to unusable. If the specified VNet has any associated Network Security Groups (NSG), then a few reserved system ports must be enabled for inbound communication. Enable ports 29876 and 29877, as well as port 22 for Linux and port 3389 for Windows. Also enable outbound connections to Azure Storage on port 443. For more details see: https://docs.microsoft.com/en-us/azure/batch/batch-api-basics#virtual-network-vnet-and-firewall-configuration
+        The virtual network must be in the same region and subscription as the Azure Batch account. The specified subnet should have enough free IP addresses to accommodate the number of nodes in the pool. If the subnet doesn't have enough free IP addresses, the pool will partially allocate compute nodes and a resize error will occur. The 'MicrosoftAzureBatch' service principal must have the 'Classic Virtual Machine Contributor' Role-Based Access Control (RBAC) role for the specified VNet. The specified subnet must allow communication from the Azure Batch service to be able to schedule tasks on the compute nodes. This can be verified by checking if the specified VNet has any associated Network Security Groups (NSG). If communication to the compute nodes in the specified subnet is denied by an NSG, then the Batch service will set the state of the compute nodes to unusable. If the specified VNet has any associated Network Security Groups (NSG), then a few reserved system ports must be enabled for inbound communication，including ports 29876 and 29877. Also enable outbound connections to Azure Storage on port 443. For more details see: https://docs.microsoft.com/en-us/azure/batch/batch-api-basics#virtual-network-vnet-and-firewall-configuration
         """
 elif False:
     NetworkConfigurationArgsDict: TypeAlias = Mapping[str, Any]
@@ -2396,7 +2396,7 @@ class NetworkConfigurationArgs:
         The network configuration for a pool.
         :param pulumi.Input[bool] enable_accelerated_networking: Accelerated networking enables single root I/O virtualization (SR-IOV) to a VM, which may lead to improved networking performance. For more details, see: https://learn.microsoft.com/azure/virtual-network/accelerated-networking-overview.
         :param pulumi.Input['PublicIPAddressConfigurationArgs'] public_ip_address_configuration: The public IP Address configuration of the networking configuration of a Pool.
-        :param pulumi.Input[str] subnet_id: The virtual network must be in the same region and subscription as the Azure Batch account. The specified subnet should have enough free IP addresses to accommodate the number of nodes in the pool. If the subnet doesn't have enough free IP addresses, the pool will partially allocate compute nodes and a resize error will occur. The 'MicrosoftAzureBatch' service principal must have the 'Classic Virtual Machine Contributor' Role-Based Access Control (RBAC) role for the specified VNet. The specified subnet must allow communication from the Azure Batch service to be able to schedule tasks on the compute nodes. This can be verified by checking if the specified VNet has any associated Network Security Groups (NSG). If communication to the compute nodes in the specified subnet is denied by an NSG, then the Batch service will set the state of the compute nodes to unusable. If the specified VNet has any associated Network Security Groups (NSG), then a few reserved system ports must be enabled for inbound communication. Enable ports 29876 and 29877, as well as port 22 for Linux and port 3389 for Windows. Also enable outbound connections to Azure Storage on port 443. For more details see: https://docs.microsoft.com/en-us/azure/batch/batch-api-basics#virtual-network-vnet-and-firewall-configuration
+        :param pulumi.Input[str] subnet_id: The virtual network must be in the same region and subscription as the Azure Batch account. The specified subnet should have enough free IP addresses to accommodate the number of nodes in the pool. If the subnet doesn't have enough free IP addresses, the pool will partially allocate compute nodes and a resize error will occur. The 'MicrosoftAzureBatch' service principal must have the 'Classic Virtual Machine Contributor' Role-Based Access Control (RBAC) role for the specified VNet. The specified subnet must allow communication from the Azure Batch service to be able to schedule tasks on the compute nodes. This can be verified by checking if the specified VNet has any associated Network Security Groups (NSG). If communication to the compute nodes in the specified subnet is denied by an NSG, then the Batch service will set the state of the compute nodes to unusable. If the specified VNet has any associated Network Security Groups (NSG), then a few reserved system ports must be enabled for inbound communication，including ports 29876 and 29877. Also enable outbound connections to Azure Storage on port 443. For more details see: https://docs.microsoft.com/en-us/azure/batch/batch-api-basics#virtual-network-vnet-and-firewall-configuration
         """
         if dynamic_vnet_assignment_scope is None:
             dynamic_vnet_assignment_scope = 'none'
@@ -2457,7 +2457,7 @@ class NetworkConfigurationArgs:
     @pulumi.getter(name="subnetId")
     def subnet_id(self) -> Optional[pulumi.Input[str]]:
         """
-        The virtual network must be in the same region and subscription as the Azure Batch account. The specified subnet should have enough free IP addresses to accommodate the number of nodes in the pool. If the subnet doesn't have enough free IP addresses, the pool will partially allocate compute nodes and a resize error will occur. The 'MicrosoftAzureBatch' service principal must have the 'Classic Virtual Machine Contributor' Role-Based Access Control (RBAC) role for the specified VNet. The specified subnet must allow communication from the Azure Batch service to be able to schedule tasks on the compute nodes. This can be verified by checking if the specified VNet has any associated Network Security Groups (NSG). If communication to the compute nodes in the specified subnet is denied by an NSG, then the Batch service will set the state of the compute nodes to unusable. If the specified VNet has any associated Network Security Groups (NSG), then a few reserved system ports must be enabled for inbound communication. Enable ports 29876 and 29877, as well as port 22 for Linux and port 3389 for Windows. Also enable outbound connections to Azure Storage on port 443. For more details see: https://docs.microsoft.com/en-us/azure/batch/batch-api-basics#virtual-network-vnet-and-firewall-configuration
+        The virtual network must be in the same region and subscription as the Azure Batch account. The specified subnet should have enough free IP addresses to accommodate the number of nodes in the pool. If the subnet doesn't have enough free IP addresses, the pool will partially allocate compute nodes and a resize error will occur. The 'MicrosoftAzureBatch' service principal must have the 'Classic Virtual Machine Contributor' Role-Based Access Control (RBAC) role for the specified VNet. The specified subnet must allow communication from the Azure Batch service to be able to schedule tasks on the compute nodes. This can be verified by checking if the specified VNet has any associated Network Security Groups (NSG). If communication to the compute nodes in the specified subnet is denied by an NSG, then the Batch service will set the state of the compute nodes to unusable. If the specified VNet has any associated Network Security Groups (NSG), then a few reserved system ports must be enabled for inbound communication，including ports 29876 and 29877. Also enable outbound connections to Azure Storage on port 443. For more details see: https://docs.microsoft.com/en-us/azure/batch/batch-api-basics#virtual-network-vnet-and-firewall-configuration
         """
         return pulumi.get(self, "subnet_id")
 

pulumi_azure_native/batch/v20240701/outputs.py

@@ -1652,7 +1652,7 @@ class InboundNatPoolResponse(dict):
                  protocol: str,
                  network_security_group_rules: Optional[Sequence['outputs.NetworkSecurityGroupRuleResponse']] = None):
         """
-        :param int backend_port: This must be unique within a Batch pool. Acceptable values are between 1 and 65535 except for 22, 3389, 29876 and 29877 as these are reserved. If any reserved values are provided the request fails with HTTP status code 400.
+        :param int backend_port: This must be unique within a Batch pool. Acceptable values are between 1 and 65535 except for 29876 and 29877 as these are reserved. If any reserved values are provided the request fails with HTTP status code 400.
         :param int frontend_port_range_end: Acceptable values range between 1 and 65534 except ports from 50000 to 55000 which are reserved by the Batch service. All ranges within a pool must be distinct and cannot overlap. If any reserved or overlapping values are provided the request fails with HTTP status code 400.
         :param int frontend_port_range_start: Acceptable values range between 1 and 65534 except ports from 50000 to 55000 which are reserved. All ranges within a pool must be distinct and cannot overlap. If any reserved or overlapping values are provided the request fails with HTTP status code 400.
         :param str name: The name must be unique within a Batch pool, can contain letters, numbers, underscores, periods, and hyphens. Names must start with a letter or number, must end with a letter, number, or underscore, and cannot exceed 77 characters.  If any invalid values are provided the request fails with HTTP status code 400.
@@ -1670,7 +1670,7 @@ class InboundNatPoolResponse(dict):
     @pulumi.getter(name="backendPort")
     def backend_port(self) -> int:
         """
-        This must be unique within a Batch pool. Acceptable values are between 1 and 65535 except for 22, 3389, 29876 and 29877 as these are reserved. If any reserved values are provided the request fails with HTTP status code 400.
+        This must be unique within a Batch pool. Acceptable values are between 1 and 65535 except for 29876 and 29877 as these are reserved. If any reserved values are provided the request fails with HTTP status code 400.
         """
         return pulumi.get(self, "backend_port")
 
@@ -2098,7 +2098,7 @@ class NetworkConfigurationResponse(dict):
         The network configuration for a pool.
         :param bool enable_accelerated_networking: Accelerated networking enables single root I/O virtualization (SR-IOV) to a VM, which may lead to improved networking performance. For more details, see: https://learn.microsoft.com/azure/virtual-network/accelerated-networking-overview.
         :param 'PublicIPAddressConfigurationResponse' public_ip_address_configuration: The public IP Address configuration of the networking configuration of a Pool.
-        :param str subnet_id: The virtual network must be in the same region and subscription as the Azure Batch account. The specified subnet should have enough free IP addresses to accommodate the number of nodes in the pool. If the subnet doesn't have enough free IP addresses, the pool will partially allocate compute nodes and a resize error will occur. The 'MicrosoftAzureBatch' service principal must have the 'Classic Virtual Machine Contributor' Role-Based Access Control (RBAC) role for the specified VNet. The specified subnet must allow communication from the Azure Batch service to be able to schedule tasks on the compute nodes. This can be verified by checking if the specified VNet has any associated Network Security Groups (NSG). If communication to the compute nodes in the specified subnet is denied by an NSG, then the Batch service will set the state of the compute nodes to unusable. If the specified VNet has any associated Network Security Groups (NSG), then a few reserved system ports must be enabled for inbound communication. Enable ports 29876 and 29877, as well as port 22 for Linux and port 3389 for Windows. Also enable outbound connections to Azure Storage on port 443. For more details see: https://docs.microsoft.com/en-us/azure/batch/batch-api-basics#virtual-network-vnet-and-firewall-configuration
+        :param str subnet_id: The virtual network must be in the same region and subscription as the Azure Batch account. The specified subnet should have enough free IP addresses to accommodate the number of nodes in the pool. If the subnet doesn't have enough free IP addresses, the pool will partially allocate compute nodes and a resize error will occur. The 'MicrosoftAzureBatch' service principal must have the 'Classic Virtual Machine Contributor' Role-Based Access Control (RBAC) role for the specified VNet. The specified subnet must allow communication from the Azure Batch service to be able to schedule tasks on the compute nodes. This can be verified by checking if the specified VNet has any associated Network Security Groups (NSG). If communication to the compute nodes in the specified subnet is denied by an NSG, then the Batch service will set the state of the compute nodes to unusable. If the specified VNet has any associated Network Security Groups (NSG), then a few reserved system ports must be enabled for inbound communication，including ports 29876 and 29877. Also enable outbound connections to Azure Storage on port 443. For more details see: https://docs.microsoft.com/en-us/azure/batch/batch-api-basics#virtual-network-vnet-and-firewall-configuration
         """
         if dynamic_vnet_assignment_scope is None:
             dynamic_vnet_assignment_scope = 'none'
@@ -2143,7 +2143,7 @@ class NetworkConfigurationResponse(dict):
     @pulumi.getter(name="subnetId")
     def subnet_id(self) -> Optional[str]:
         """
-        The virtual network must be in the same region and subscription as the Azure Batch account. The specified subnet should have enough free IP addresses to accommodate the number of nodes in the pool. If the subnet doesn't have enough free IP addresses, the pool will partially allocate compute nodes and a resize error will occur. The 'MicrosoftAzureBatch' service principal must have the 'Classic Virtual Machine Contributor' Role-Based Access Control (RBAC) role for the specified VNet. The specified subnet must allow communication from the Azure Batch service to be able to schedule tasks on the compute nodes. This can be verified by checking if the specified VNet has any associated Network Security Groups (NSG). If communication to the compute nodes in the specified subnet is denied by an NSG, then the Batch service will set the state of the compute nodes to unusable. If the specified VNet has any associated Network Security Groups (NSG), then a few reserved system ports must be enabled for inbound communication. Enable ports 29876 and 29877, as well as port 22 for Linux and port 3389 for Windows. Also enable outbound connections to Azure Storage on port 443. For more details see: https://docs.microsoft.com/en-us/azure/batch/batch-api-basics#virtual-network-vnet-and-firewall-configuration
+        The virtual network must be in the same region and subscription as the Azure Batch account. The specified subnet should have enough free IP addresses to accommodate the number of nodes in the pool. If the subnet doesn't have enough free IP addresses, the pool will partially allocate compute nodes and a resize error will occur. The 'MicrosoftAzureBatch' service principal must have the 'Classic Virtual Machine Contributor' Role-Based Access Control (RBAC) role for the specified VNet. The specified subnet must allow communication from the Azure Batch service to be able to schedule tasks on the compute nodes. This can be verified by checking if the specified VNet has any associated Network Security Groups (NSG). If communication to the compute nodes in the specified subnet is denied by an NSG, then the Batch service will set the state of the compute nodes to unusable. If the specified VNet has any associated Network Security Groups (NSG), then a few reserved system ports must be enabled for inbound communication，including ports 29876 and 29877. Also enable outbound connections to Azure Storage on port 443. For more details see: https://docs.microsoft.com/en-us/azure/batch/batch-api-basics#virtual-network-vnet-and-firewall-configuration
         """
         return pulumi.get(self, "subnet_id")
 

pulumi_azure_native/cdn/v20240901/_inputs.py

@@ -7953,15 +7953,15 @@ if not MYPY:
         """
         Resource reference to the Azure Key Vault secret. Expected to be in format of /subscriptions/{​​​​​​​​​subscriptionId}​​​​​​​​​/resourceGroups/{​​​​​​​​​resourceGroupName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​/providers/Microsoft.KeyVault/vaults/{vaultName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​/secrets/{secretName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​
         """
+        secret_version: pulumi.Input[str]
+        """
+        Version of the secret to be used
+        """
         type: pulumi.Input[str]
         """
         The type of the secret resource.
         Expected value is 'UrlSigningKey'.
         """
-        secret_version: NotRequired[pulumi.Input[str]]
-        """
-        Version of the secret to be used
-        """
 elif False:
     UrlSigningKeyParametersArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -7970,21 +7970,20 @@ class UrlSigningKeyParametersArgs:
     def __init__(__self__, *,
                  key_id: pulumi.Input[str],
                  secret_source: pulumi.Input['ResourceReferenceArgs'],
-                 type: pulumi.Input[str],
-                 secret_version: Optional[pulumi.Input[str]] = None):
+                 secret_version: pulumi.Input[str],
+                 type: pulumi.Input[str]):
         """
         Url signing key parameters
         :param pulumi.Input[str] key_id: Defines the customer defined key Id. This id will exist in the incoming request to indicate the key used to form the hash.
         :param pulumi.Input['ResourceReferenceArgs'] secret_source: Resource reference to the Azure Key Vault secret. Expected to be in format of /subscriptions/{​​​​​​​​​subscriptionId}​​​​​​​​​/resourceGroups/{​​​​​​​​​resourceGroupName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​/providers/Microsoft.KeyVault/vaults/{vaultName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​/secrets/{secretName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​
+        :param pulumi.Input[str] secret_version: Version of the secret to be used
         :param pulumi.Input[str] type: The type of the secret resource.
                Expected value is 'UrlSigningKey'.
-        :param pulumi.Input[str] secret_version: Version of the secret to be used
         """
         pulumi.set(__self__, "key_id", key_id)
         pulumi.set(__self__, "secret_source", secret_source)
+        pulumi.set(__self__, "secret_version", secret_version)
         pulumi.set(__self__, "type", 'UrlSigningKey')
-        if secret_version is not None:
-            pulumi.set(__self__, "secret_version", secret_version)
 
     @property
     @pulumi.getter(name="keyId")
@@ -8010,6 +8009,18 @@ class UrlSigningKeyParametersArgs:
     def secret_source(self, value: pulumi.Input['ResourceReferenceArgs']):
         pulumi.set(self, "secret_source", value)
 
+    @property
+    @pulumi.getter(name="secretVersion")
+    def secret_version(self) -> pulumi.Input[str]:
+        """
+        Version of the secret to be used
+        """
+        return pulumi.get(self, "secret_version")
+
+    @secret_version.setter
+    def secret_version(self, value: pulumi.Input[str]):
+        pulumi.set(self, "secret_version", value)
+
     @property
     @pulumi.getter
     def type(self) -> pulumi.Input[str]:
@@ -8023,18 +8034,6 @@ class UrlSigningKeyParametersArgs:
     def type(self, value: pulumi.Input[str]):
         pulumi.set(self, "type", value)
 
-    @property
-    @pulumi.getter(name="secretVersion")
-    def secret_version(self) -> Optional[pulumi.Input[str]]:
-        """
-        Version of the secret to be used
-        """
-        return pulumi.get(self, "secret_version")
-
-    @secret_version.setter
-    def secret_version(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "secret_version", value)
-
 
 if not MYPY:
     class UrlSigningKeyArgsDict(TypedDict):

pulumi_azure_native/cdn/v20240901/outputs.py

@@ -6779,21 +6779,20 @@ class UrlSigningKeyParametersResponse(dict):
     def __init__(__self__, *,
                  key_id: str,
                  secret_source: 'outputs.ResourceReferenceResponse',
-                 type: str,
-                 secret_version: Optional[str] = None):
+                 secret_version: str,
+                 type: str):
         """
         Url signing key parameters
         :param str key_id: Defines the customer defined key Id. This id will exist in the incoming request to indicate the key used to form the hash.
         :param 'ResourceReferenceResponse' secret_source: Resource reference to the Azure Key Vault secret. Expected to be in format of /subscriptions/{​​​​​​​​​subscriptionId}​​​​​​​​​/resourceGroups/{​​​​​​​​​resourceGroupName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​/providers/Microsoft.KeyVault/vaults/{vaultName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​/secrets/{secretName}​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​
+        :param str secret_version: Version of the secret to be used
         :param str type: The type of the secret resource.
                Expected value is 'UrlSigningKey'.
-        :param str secret_version: Version of the secret to be used
         """
         pulumi.set(__self__, "key_id", key_id)
         pulumi.set(__self__, "secret_source", secret_source)
+        pulumi.set(__self__, "secret_version", secret_version)
         pulumi.set(__self__, "type", 'UrlSigningKey')
-        if secret_version is not None:
-            pulumi.set(__self__, "secret_version", secret_version)
 
     @property
     @pulumi.getter(name="keyId")
@@ -6811,6 +6810,14 @@ class UrlSigningKeyParametersResponse(dict):
         """
         return pulumi.get(self, "secret_source")
 
+    @property
+    @pulumi.getter(name="secretVersion")
+    def secret_version(self) -> str:
+        """
+        Version of the secret to be used
+        """
+        return pulumi.get(self, "secret_version")
+
     @property
     @pulumi.getter
     def type(self) -> str:
@@ -6820,14 +6827,6 @@ class UrlSigningKeyParametersResponse(dict):
         """
         return pulumi.get(self, "type")
 
-    @property
-    @pulumi.getter(name="secretVersion")
-    def secret_version(self) -> Optional[str]:
-        """
-        Version of the secret to be used
-        """
-        return pulumi.get(self, "secret_version")
-
 
 @pulumi.output_type
 class UrlSigningKeyResponse(dict):

pulumi_azure_native/containerinstance/__init__.py

@@ -6,8 +6,10 @@ from .. import _utilities
 import typing
 # Export this package's modules as members:
 from ._enums import *
+from .cg_profile import *
 from .container_group import *
 from .container_group_profile import *
+from .get_cg_profile import *
 from .get_container_group import *
 from .get_container_group_profile import *
 from .get_n_group import *
@@ -31,6 +33,8 @@ if typing.TYPE_CHECKING:
     v20240901preview = __v20240901preview
     import pulumi_azure_native.containerinstance.v20241001preview as __v20241001preview
     v20241001preview = __v20241001preview
+    import pulumi_azure_native.containerinstance.v20241101preview as __v20241101preview
+    v20241101preview = __v20241101preview
 else:
     v20210301 = _utilities.lazy_import('pulumi_azure_native.containerinstance.v20210301')
     v20210701 = _utilities.lazy_import('pulumi_azure_native.containerinstance.v20210701')
@@ -39,4 +43,5 @@ else:
     v20240501preview = _utilities.lazy_import('pulumi_azure_native.containerinstance.v20240501preview')
     v20240901preview = _utilities.lazy_import('pulumi_azure_native.containerinstance.v20240901preview')
     v20241001preview = _utilities.lazy_import('pulumi_azure_native.containerinstance.v20241001preview')
+    v20241101preview = _utilities.lazy_import('pulumi_azure_native.containerinstance.v20241101preview')
 

pulumi_azure_native/containerinstance/_inputs.py

@@ -145,6 +145,10 @@ if not MYPY:
         """
         The storage account access key used to access the Azure File share.
         """
+        storage_account_key_reference: NotRequired[pulumi.Input[str]]
+        """
+        The reference to the storage account access key used to access the Azure File share.
+        """
 elif False:
     AzureFileVolumeArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -154,13 +158,15 @@ class AzureFileVolumeArgs:
                  share_name: pulumi.Input[str],
                  storage_account_name: pulumi.Input[str],
                  read_only: Optional[pulumi.Input[bool]] = None,
-                 storage_account_key: Optional[pulumi.Input[str]] = None):
+                 storage_account_key: Optional[pulumi.Input[str]] = None,
+                 storage_account_key_reference: Optional[pulumi.Input[str]] = None):
         """
         The properties of the Azure File volume. Azure File shares are mounted as volumes.
         :param pulumi.Input[str] share_name: The name of the Azure File share to be mounted as a volume.
         :param pulumi.Input[str] storage_account_name: The name of the storage account that contains the Azure File share.
         :param pulumi.Input[bool] read_only: The flag indicating whether the Azure File shared mounted as a volume is read-only.
         :param pulumi.Input[str] storage_account_key: The storage account access key used to access the Azure File share.
+        :param pulumi.Input[str] storage_account_key_reference: The reference to the storage account access key used to access the Azure File share.
         """
         pulumi.set(__self__, "share_name", share_name)
         pulumi.set(__self__, "storage_account_name", storage_account_name)
@@ -168,6 +174,8 @@ class AzureFileVolumeArgs:
             pulumi.set(__self__, "read_only", read_only)
         if storage_account_key is not None:
             pulumi.set(__self__, "storage_account_key", storage_account_key)
+        if storage_account_key_reference is not None:
+            pulumi.set(__self__, "storage_account_key_reference", storage_account_key_reference)
 
     @property
     @pulumi.getter(name="shareName")
@@ -217,6 +225,18 @@ class AzureFileVolumeArgs:
     def storage_account_key(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "storage_account_key", value)
 
+    @property
+    @pulumi.getter(name="storageAccountKeyReference")
+    def storage_account_key_reference(self) -> Optional[pulumi.Input[str]]:
+        """
+        The reference to the storage account access key used to access the Azure File share.
+        """
+        return pulumi.get(self, "storage_account_key_reference")
+
+    @storage_account_key_reference.setter
+    def storage_account_key_reference(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "storage_account_key_reference", value)
+
 
 if not MYPY:
     class ConfidentialComputePropertiesArgsDict(TypedDict):
@@ -1373,6 +1393,10 @@ if not MYPY:
         """
         The value of the secure environment variable.
         """
+        secure_value_reference: NotRequired[pulumi.Input[str]]
+        """
+        The reference of the secure environment variable.
+        """
         value: NotRequired[pulumi.Input[str]]
         """
         The value of the environment variable.
@@ -1385,16 +1409,20 @@ class EnvironmentVariableArgs:
     def __init__(__self__, *,
                  name: pulumi.Input[str],
                  secure_value: Optional[pulumi.Input[str]] = None,
+                 secure_value_reference: Optional[pulumi.Input[str]] = None,
                  value: Optional[pulumi.Input[str]] = None):
         """
         The environment variable to set within the container instance.
         :param pulumi.Input[str] name: The name of the environment variable.
         :param pulumi.Input[str] secure_value: The value of the secure environment variable.
+        :param pulumi.Input[str] secure_value_reference: The reference of the secure environment variable.
         :param pulumi.Input[str] value: The value of the environment variable.
         """
         pulumi.set(__self__, "name", name)
         if secure_value is not None:
             pulumi.set(__self__, "secure_value", secure_value)
+        if secure_value_reference is not None:
+            pulumi.set(__self__, "secure_value_reference", secure_value_reference)
         if value is not None:
             pulumi.set(__self__, "value", value)
 
@@ -1422,6 +1450,18 @@ class EnvironmentVariableArgs:
     def secure_value(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "secure_value", value)
 
+    @property
+    @pulumi.getter(name="secureValueReference")
+    def secure_value_reference(self) -> Optional[pulumi.Input[str]]:
+        """
+        The reference of the secure environment variable.
+        """
+        return pulumi.get(self, "secure_value_reference")
+
+    @secure_value_reference.setter
+    def secure_value_reference(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "secure_value_reference", value)
+
     @property
     @pulumi.getter
     def value(self) -> Optional[pulumi.Input[str]]:
@@ -1641,6 +1681,10 @@ if not MYPY:
         """
         The password for the private registry.
         """
+        password_reference: NotRequired[pulumi.Input[str]]
+        """
+        The reference for the private registry password.
+        """
         username: NotRequired[pulumi.Input[str]]
         """
         The username for the private registry.
@@ -1655,6 +1699,7 @@ class ImageRegistryCredentialArgs:
                  identity: Optional[pulumi.Input[str]] = None,
                  identity_url: Optional[pulumi.Input[str]] = None,
                  password: Optional[pulumi.Input[str]] = None,
+                 password_reference: Optional[pulumi.Input[str]] = None,
                  username: Optional[pulumi.Input[str]] = None):
         """
         Image registry credential.
@@ -1662,6 +1707,7 @@ class ImageRegistryCredentialArgs:
         :param pulumi.Input[str] identity: The identity for the private registry.
         :param pulumi.Input[str] identity_url: The identity URL for the private registry.
         :param pulumi.Input[str] password: The password for the private registry.
+        :param pulumi.Input[str] password_reference: The reference for the private registry password.
         :param pulumi.Input[str] username: The username for the private registry.
         """
         pulumi.set(__self__, "server", server)
@@ -1671,6 +1717,8 @@ class ImageRegistryCredentialArgs:
             pulumi.set(__self__, "identity_url", identity_url)
         if password is not None:
             pulumi.set(__self__, "password", password)
+        if password_reference is not None:
+            pulumi.set(__self__, "password_reference", password_reference)
         if username is not None:
             pulumi.set(__self__, "username", username)
 
@@ -1722,6 +1770,18 @@ class ImageRegistryCredentialArgs:
     def password(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "password", value)
 
+    @property
+    @pulumi.getter(name="passwordReference")
+    def password_reference(self) -> Optional[pulumi.Input[str]]:
+        """
+        The reference for the private registry password.
+        """
+        return pulumi.get(self, "password_reference")
+
+    @password_reference.setter
+    def password_reference(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "password_reference", value)
+
     @property
     @pulumi.getter
     def username(self) -> Optional[pulumi.Input[str]]:
@@ -2707,6 +2767,10 @@ if not MYPY:
         """
         The secret volume.
         """
+        secret_reference: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        The secret reference volume.
+        """
 elif False:
     VolumeArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -2717,7 +2781,8 @@ class VolumeArgs:
                  azure_file: Optional[pulumi.Input['AzureFileVolumeArgs']] = None,
                  empty_dir: Optional[Any] = None,
                  git_repo: Optional[pulumi.Input['GitRepoVolumeArgs']] = None,
-                 secret: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
+                 secret: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 secret_reference: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
         """
         The properties of the volume.
         :param pulumi.Input[str] name: The name of the volume.
@@ -2725,6 +2790,7 @@ class VolumeArgs:
         :param Any empty_dir: The empty directory volume.
         :param pulumi.Input['GitRepoVolumeArgs'] git_repo: The git repo volume.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] secret: The secret volume.
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] secret_reference: The secret reference volume.
         """
         pulumi.set(__self__, "name", name)
         if azure_file is not None:
@@ -2735,6 +2801,8 @@ class VolumeArgs:
             pulumi.set(__self__, "git_repo", git_repo)
         if secret is not None:
             pulumi.set(__self__, "secret", secret)
+        if secret_reference is not None:
+            pulumi.set(__self__, "secret_reference", secret_reference)
 
     @property
     @pulumi.getter
@@ -2796,4 +2864,16 @@ class VolumeArgs:
     def secret(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "secret", value)
 
+    @property
+    @pulumi.getter(name="secretReference")
+    def secret_reference(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
+        """
+        The secret reference volume.
+        """
+        return pulumi.get(self, "secret_reference")
+
+    @secret_reference.setter
+    def secret_reference(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
+        pulumi.set(self, "secret_reference", value)
+