pulumi-azure-native 2.62.0a1726562525__py3-none-any.whl → 2.63.0a1727187288__py3-none-any.whl

pulumi_azure_native/sql/v20240501preview/get_managed_instance.py

@@ -0,0 +1,640 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from ... import _utilities
+from . import outputs
+
+__all__ = [
+    'GetManagedInstanceResult',
+    'AwaitableGetManagedInstanceResult',
+    'get_managed_instance',
+    'get_managed_instance_output',
+]
+
+@pulumi.output_type
+class GetManagedInstanceResult:
+    """
+    An Azure SQL managed instance.
+    """
+    def __init__(__self__, administrator_login=None, administrators=None, authentication_metadata=None, collation=None, create_time=None, current_backup_storage_redundancy=None, database_format=None, dns_zone=None, external_governance_status=None, fully_qualified_domain_name=None, hybrid_secondary_usage=None, hybrid_secondary_usage_detected=None, id=None, identity=None, instance_pool_id=None, is_general_purpose_v2=None, key_id=None, license_type=None, location=None, maintenance_configuration_id=None, minimal_tls_version=None, name=None, pricing_model=None, primary_user_assigned_identity_id=None, private_endpoint_connections=None, provisioning_state=None, proxy_override=None, public_data_endpoint_enabled=None, requested_backup_storage_redundancy=None, service_principal=None, sku=None, state=None, storage_i_ops=None, storage_size_in_gb=None, storage_throughput_m_bps=None, subnet_id=None, tags=None, timezone_id=None, total_memory_mb=None, type=None, v_cores=None, virtual_cluster_id=None, zone_redundant=None):
+        if administrator_login and not isinstance(administrator_login, str):
+            raise TypeError("Expected argument 'administrator_login' to be a str")
+        pulumi.set(__self__, "administrator_login", administrator_login)
+        if administrators and not isinstance(administrators, dict):
+            raise TypeError("Expected argument 'administrators' to be a dict")
+        pulumi.set(__self__, "administrators", administrators)
+        if authentication_metadata and not isinstance(authentication_metadata, str):
+            raise TypeError("Expected argument 'authentication_metadata' to be a str")
+        pulumi.set(__self__, "authentication_metadata", authentication_metadata)
+        if collation and not isinstance(collation, str):
+            raise TypeError("Expected argument 'collation' to be a str")
+        pulumi.set(__self__, "collation", collation)
+        if create_time and not isinstance(create_time, str):
+            raise TypeError("Expected argument 'create_time' to be a str")
+        pulumi.set(__self__, "create_time", create_time)
+        if current_backup_storage_redundancy and not isinstance(current_backup_storage_redundancy, str):
+            raise TypeError("Expected argument 'current_backup_storage_redundancy' to be a str")
+        pulumi.set(__self__, "current_backup_storage_redundancy", current_backup_storage_redundancy)
+        if database_format and not isinstance(database_format, str):
+            raise TypeError("Expected argument 'database_format' to be a str")
+        pulumi.set(__self__, "database_format", database_format)
+        if dns_zone and not isinstance(dns_zone, str):
+            raise TypeError("Expected argument 'dns_zone' to be a str")
+        pulumi.set(__self__, "dns_zone", dns_zone)
+        if external_governance_status and not isinstance(external_governance_status, str):
+            raise TypeError("Expected argument 'external_governance_status' to be a str")
+        pulumi.set(__self__, "external_governance_status", external_governance_status)
+        if fully_qualified_domain_name and not isinstance(fully_qualified_domain_name, str):
+            raise TypeError("Expected argument 'fully_qualified_domain_name' to be a str")
+        pulumi.set(__self__, "fully_qualified_domain_name", fully_qualified_domain_name)
+        if hybrid_secondary_usage and not isinstance(hybrid_secondary_usage, str):
+            raise TypeError("Expected argument 'hybrid_secondary_usage' to be a str")
+        pulumi.set(__self__, "hybrid_secondary_usage", hybrid_secondary_usage)
+        if hybrid_secondary_usage_detected and not isinstance(hybrid_secondary_usage_detected, str):
+            raise TypeError("Expected argument 'hybrid_secondary_usage_detected' to be a str")
+        pulumi.set(__self__, "hybrid_secondary_usage_detected", hybrid_secondary_usage_detected)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if identity and not isinstance(identity, dict):
+            raise TypeError("Expected argument 'identity' to be a dict")
+        pulumi.set(__self__, "identity", identity)
+        if instance_pool_id and not isinstance(instance_pool_id, str):
+            raise TypeError("Expected argument 'instance_pool_id' to be a str")
+        pulumi.set(__self__, "instance_pool_id", instance_pool_id)
+        if is_general_purpose_v2 and not isinstance(is_general_purpose_v2, bool):
+            raise TypeError("Expected argument 'is_general_purpose_v2' to be a bool")
+        pulumi.set(__self__, "is_general_purpose_v2", is_general_purpose_v2)
+        if key_id and not isinstance(key_id, str):
+            raise TypeError("Expected argument 'key_id' to be a str")
+        pulumi.set(__self__, "key_id", key_id)
+        if license_type and not isinstance(license_type, str):
+            raise TypeError("Expected argument 'license_type' to be a str")
+        pulumi.set(__self__, "license_type", license_type)
+        if location and not isinstance(location, str):
+            raise TypeError("Expected argument 'location' to be a str")
+        pulumi.set(__self__, "location", location)
+        if maintenance_configuration_id and not isinstance(maintenance_configuration_id, str):
+            raise TypeError("Expected argument 'maintenance_configuration_id' to be a str")
+        pulumi.set(__self__, "maintenance_configuration_id", maintenance_configuration_id)
+        if minimal_tls_version and not isinstance(minimal_tls_version, str):
+            raise TypeError("Expected argument 'minimal_tls_version' to be a str")
+        pulumi.set(__self__, "minimal_tls_version", minimal_tls_version)
+        if name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", name)
+        if pricing_model and not isinstance(pricing_model, str):
+            raise TypeError("Expected argument 'pricing_model' to be a str")
+        pulumi.set(__self__, "pricing_model", pricing_model)
+        if primary_user_assigned_identity_id and not isinstance(primary_user_assigned_identity_id, str):
+            raise TypeError("Expected argument 'primary_user_assigned_identity_id' to be a str")
+        pulumi.set(__self__, "primary_user_assigned_identity_id", primary_user_assigned_identity_id)
+        if private_endpoint_connections and not isinstance(private_endpoint_connections, list):
+            raise TypeError("Expected argument 'private_endpoint_connections' to be a list")
+        pulumi.set(__self__, "private_endpoint_connections", private_endpoint_connections)
+        if provisioning_state and not isinstance(provisioning_state, str):
+            raise TypeError("Expected argument 'provisioning_state' to be a str")
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if proxy_override and not isinstance(proxy_override, str):
+            raise TypeError("Expected argument 'proxy_override' to be a str")
+        pulumi.set(__self__, "proxy_override", proxy_override)
+        if public_data_endpoint_enabled and not isinstance(public_data_endpoint_enabled, bool):
+            raise TypeError("Expected argument 'public_data_endpoint_enabled' to be a bool")
+        pulumi.set(__self__, "public_data_endpoint_enabled", public_data_endpoint_enabled)
+        if requested_backup_storage_redundancy and not isinstance(requested_backup_storage_redundancy, str):
+            raise TypeError("Expected argument 'requested_backup_storage_redundancy' to be a str")
+        pulumi.set(__self__, "requested_backup_storage_redundancy", requested_backup_storage_redundancy)
+        if service_principal and not isinstance(service_principal, dict):
+            raise TypeError("Expected argument 'service_principal' to be a dict")
+        pulumi.set(__self__, "service_principal", service_principal)
+        if sku and not isinstance(sku, dict):
+            raise TypeError("Expected argument 'sku' to be a dict")
+        pulumi.set(__self__, "sku", sku)
+        if state and not isinstance(state, str):
+            raise TypeError("Expected argument 'state' to be a str")
+        pulumi.set(__self__, "state", state)
+        if storage_i_ops and not isinstance(storage_i_ops, int):
+            raise TypeError("Expected argument 'storage_i_ops' to be a int")
+        pulumi.set(__self__, "storage_i_ops", storage_i_ops)
+        if storage_size_in_gb and not isinstance(storage_size_in_gb, int):
+            raise TypeError("Expected argument 'storage_size_in_gb' to be a int")
+        pulumi.set(__self__, "storage_size_in_gb", storage_size_in_gb)
+        if storage_throughput_m_bps and not isinstance(storage_throughput_m_bps, int):
+            raise TypeError("Expected argument 'storage_throughput_m_bps' to be a int")
+        pulumi.set(__self__, "storage_throughput_m_bps", storage_throughput_m_bps)
+        if subnet_id and not isinstance(subnet_id, str):
+            raise TypeError("Expected argument 'subnet_id' to be a str")
+        pulumi.set(__self__, "subnet_id", subnet_id)
+        if tags and not isinstance(tags, dict):
+            raise TypeError("Expected argument 'tags' to be a dict")
+        pulumi.set(__self__, "tags", tags)
+        if timezone_id and not isinstance(timezone_id, str):
+            raise TypeError("Expected argument 'timezone_id' to be a str")
+        pulumi.set(__self__, "timezone_id", timezone_id)
+        if total_memory_mb and not isinstance(total_memory_mb, int):
+            raise TypeError("Expected argument 'total_memory_mb' to be a int")
+        pulumi.set(__self__, "total_memory_mb", total_memory_mb)
+        if type and not isinstance(type, str):
+            raise TypeError("Expected argument 'type' to be a str")
+        pulumi.set(__self__, "type", type)
+        if v_cores and not isinstance(v_cores, int):
+            raise TypeError("Expected argument 'v_cores' to be a int")
+        pulumi.set(__self__, "v_cores", v_cores)
+        if virtual_cluster_id and not isinstance(virtual_cluster_id, str):
+            raise TypeError("Expected argument 'virtual_cluster_id' to be a str")
+        pulumi.set(__self__, "virtual_cluster_id", virtual_cluster_id)
+        if zone_redundant and not isinstance(zone_redundant, bool):
+            raise TypeError("Expected argument 'zone_redundant' to be a bool")
+        pulumi.set(__self__, "zone_redundant", zone_redundant)
+
+    @property
+    @pulumi.getter(name="administratorLogin")
+    def administrator_login(self) -> Optional[str]:
+        """
+        Administrator username for the managed instance. Can only be specified when the managed instance is being created (and is required for creation).
+        """
+        return pulumi.get(self, "administrator_login")
+
+    @property
+    @pulumi.getter
+    def administrators(self) -> Optional['outputs.ManagedInstanceExternalAdministratorResponse']:
+        """
+        The Azure Active Directory administrator of the instance. This can only be used at instance create time. If used for instance update, it will be ignored or it will result in an error. For updates individual APIs will need to be used.
+        """
+        return pulumi.get(self, "administrators")
+
+    @property
+    @pulumi.getter(name="authenticationMetadata")
+    def authentication_metadata(self) -> Optional[str]:
+        """
+        The managed instance's authentication metadata lookup mode.
+        """
+        return pulumi.get(self, "authentication_metadata")
+
+    @property
+    @pulumi.getter
+    def collation(self) -> Optional[str]:
+        """
+        Collation of the managed instance.
+        """
+        return pulumi.get(self, "collation")
+
+    @property
+    @pulumi.getter(name="createTime")
+    def create_time(self) -> str:
+        """
+        Specifies the point in time (ISO8601 format) of the Managed Instance creation.
+        """
+        return pulumi.get(self, "create_time")
+
+    @property
+    @pulumi.getter(name="currentBackupStorageRedundancy")
+    def current_backup_storage_redundancy(self) -> str:
+        """
+        The storage account type used to store backups for this instance. The options are Local (LocallyRedundantStorage), Zone (ZoneRedundantStorage), Geo (GeoRedundantStorage) and GeoZone(GeoZoneRedundantStorage)
+        """
+        return pulumi.get(self, "current_backup_storage_redundancy")
+
+    @property
+    @pulumi.getter(name="databaseFormat")
+    def database_format(self) -> Optional[str]:
+        """
+        Specifies the internal format of instance databases specific to the SQL engine version.
+        """
+        return pulumi.get(self, "database_format")
+
+    @property
+    @pulumi.getter(name="dnsZone")
+    def dns_zone(self) -> str:
+        """
+        The Dns Zone that the managed instance is in.
+        """
+        return pulumi.get(self, "dns_zone")
+
+    @property
+    @pulumi.getter(name="externalGovernanceStatus")
+    def external_governance_status(self) -> str:
+        """
+        Status of external governance.
+        """
+        return pulumi.get(self, "external_governance_status")
+
+    @property
+    @pulumi.getter(name="fullyQualifiedDomainName")
+    def fully_qualified_domain_name(self) -> str:
+        """
+        The fully qualified domain name of the managed instance.
+        """
+        return pulumi.get(self, "fully_qualified_domain_name")
+
+    @property
+    @pulumi.getter(name="hybridSecondaryUsage")
+    def hybrid_secondary_usage(self) -> Optional[str]:
+        """
+        Hybrid secondary usage. Possible values are 'Active' (default value) and 'Passive' (customer uses the secondary as Passive DR).
+        """
+        return pulumi.get(self, "hybrid_secondary_usage")
+
+    @property
+    @pulumi.getter(name="hybridSecondaryUsageDetected")
+    def hybrid_secondary_usage_detected(self) -> str:
+        """
+        Hybrid secondary usage detected. Possible values are 'Active' (customer does not meet the requirements to use the secondary as Passive DR) and 'Passive' (customer meets the requirements to use the secondary as Passive DR).
+        """
+        return pulumi.get(self, "hybrid_secondary_usage_detected")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        Resource ID.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def identity(self) -> Optional['outputs.ResourceIdentityResponse']:
+        """
+        The Azure Active Directory identity of the managed instance.
+        """
+        return pulumi.get(self, "identity")
+
+    @property
+    @pulumi.getter(name="instancePoolId")
+    def instance_pool_id(self) -> Optional[str]:
+        """
+        The Id of the instance pool this managed server belongs to.
+        """
+        return pulumi.get(self, "instance_pool_id")
+
+    @property
+    @pulumi.getter(name="isGeneralPurposeV2")
+    def is_general_purpose_v2(self) -> Optional[bool]:
+        """
+        Whether or not this is a GPv2 variant of General Purpose edition.
+        """
+        return pulumi.get(self, "is_general_purpose_v2")
+
+    @property
+    @pulumi.getter(name="keyId")
+    def key_id(self) -> Optional[str]:
+        """
+        A CMK URI of the key to use for encryption.
+        """
+        return pulumi.get(self, "key_id")
+
+    @property
+    @pulumi.getter(name="licenseType")
+    def license_type(self) -> Optional[str]:
+        """
+        The license type. Possible values are 'LicenseIncluded' (regular price inclusive of a new SQL license) and 'BasePrice' (discounted AHB price for bringing your own SQL licenses).
+        """
+        return pulumi.get(self, "license_type")
+
+    @property
+    @pulumi.getter
+    def location(self) -> str:
+        """
+        Resource location.
+        """
+        return pulumi.get(self, "location")
+
+    @property
+    @pulumi.getter(name="maintenanceConfigurationId")
+    def maintenance_configuration_id(self) -> Optional[str]:
+        """
+        Specifies maintenance configuration id to apply to this managed instance.
+        """
+        return pulumi.get(self, "maintenance_configuration_id")
+
+    @property
+    @pulumi.getter(name="minimalTlsVersion")
+    def minimal_tls_version(self) -> Optional[str]:
+        """
+        Minimal TLS version. Allowed values: 'None', '1.0', '1.1', '1.2'
+        """
+        return pulumi.get(self, "minimal_tls_version")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        Resource name.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="pricingModel")
+    def pricing_model(self) -> Optional[str]:
+        """
+        Pricing model of Managed Instance.
+        """
+        return pulumi.get(self, "pricing_model")
+
+    @property
+    @pulumi.getter(name="primaryUserAssignedIdentityId")
+    def primary_user_assigned_identity_id(self) -> Optional[str]:
+        """
+        The resource id of a user assigned identity to be used by default.
+        """
+        return pulumi.get(self, "primary_user_assigned_identity_id")
+
+    @property
+    @pulumi.getter(name="privateEndpointConnections")
+    def private_endpoint_connections(self) -> Sequence['outputs.ManagedInstancePecPropertyResponse']:
+        """
+        List of private endpoint connections on a managed instance.
+        """
+        return pulumi.get(self, "private_endpoint_connections")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> str:
+        """
+        Provisioning state of managed instance.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="proxyOverride")
+    def proxy_override(self) -> Optional[str]:
+        """
+        Connection type used for connecting to the instance.
+        """
+        return pulumi.get(self, "proxy_override")
+
+    @property
+    @pulumi.getter(name="publicDataEndpointEnabled")
+    def public_data_endpoint_enabled(self) -> Optional[bool]:
+        """
+        Whether or not the public data endpoint is enabled.
+        """
+        return pulumi.get(self, "public_data_endpoint_enabled")
+
+    @property
+    @pulumi.getter(name="requestedBackupStorageRedundancy")
+    def requested_backup_storage_redundancy(self) -> Optional[str]:
+        """
+        The storage account type to be used to store backups for this instance. The options are Local (LocallyRedundantStorage), Zone (ZoneRedundantStorage), Geo (GeoRedundantStorage) and GeoZone(GeoZoneRedundantStorage)
+        """
+        return pulumi.get(self, "requested_backup_storage_redundancy")
+
+    @property
+    @pulumi.getter(name="servicePrincipal")
+    def service_principal(self) -> Optional['outputs.ServicePrincipalResponse']:
+        """
+        The managed instance's service principal.
+        """
+        return pulumi.get(self, "service_principal")
+
+    @property
+    @pulumi.getter
+    def sku(self) -> Optional['outputs.SkuResponse']:
+        """
+        Managed instance SKU. Allowed values for sku.name: GP_Gen5, GP_G8IM, GP_G8IH, BC_Gen5, BC_G8IM, BC_G8IH
+        """
+        return pulumi.get(self, "sku")
+
+    @property
+    @pulumi.getter
+    def state(self) -> str:
+        """
+        The state of the managed instance.
+        """
+        return pulumi.get(self, "state")
+
+    @property
+    @pulumi.getter(name="storageIOps")
+    def storage_i_ops(self) -> Optional[int]:
+        """
+        Storage IOps. Minimum value: 300. Maximum value: 80000. Increments of 1 IOps allowed only. Maximum value depends on the selected hardware family and number of vCores.
+        """
+        return pulumi.get(self, "storage_i_ops")
+
+    @property
+    @pulumi.getter(name="storageSizeInGB")
+    def storage_size_in_gb(self) -> Optional[int]:
+        """
+        Storage size in GB. Minimum value: 32. Maximum value: 16384. Increments of 32 GB allowed only. Maximum value depends on the selected hardware family and number of vCores.
+        """
+        return pulumi.get(self, "storage_size_in_gb")
+
+    @property
+    @pulumi.getter(name="storageThroughputMBps")
+    def storage_throughput_m_bps(self) -> Optional[int]:
+        """
+        Storage throughput MBps parameter is not supported in the instance create/update operation.
+        """
+        return pulumi.get(self, "storage_throughput_m_bps")
+
+    @property
+    @pulumi.getter(name="subnetId")
+    def subnet_id(self) -> Optional[str]:
+        """
+        Subnet resource ID for the managed instance.
+        """
+        return pulumi.get(self, "subnet_id")
+
+    @property
+    @pulumi.getter
+    def tags(self) -> Optional[Mapping[str, str]]:
+        """
+        Resource tags.
+        """
+        return pulumi.get(self, "tags")
+
+    @property
+    @pulumi.getter(name="timezoneId")
+    def timezone_id(self) -> Optional[str]:
+        """
+        Id of the timezone. Allowed values are timezones supported by Windows.
+        Windows keeps details on supported timezones, including the id, in registry under
+        KEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones.
+        You can get those registry values via SQL Server by querying SELECT name AS timezone_id FROM sys.time_zone_info.
+        List of Ids can also be obtained by executing [System.TimeZoneInfo]::GetSystemTimeZones() in PowerShell.
+        An example of valid timezone id is "Pacific Standard Time" or "W. Europe Standard Time".
+        """
+        return pulumi.get(self, "timezone_id")
+
+    @property
+    @pulumi.getter(name="totalMemoryMB")
+    def total_memory_mb(self) -> Optional[int]:
+        """
+        Total memory in MB. Minimum value: 7168. Maximum value: 891328. Increments of 1 MB allowed only. Maximum value depends on the selected hardware family and number of vCores.
+        """
+        return pulumi.get(self, "total_memory_mb")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        Resource type.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="vCores")
+    def v_cores(self) -> Optional[int]:
+        """
+        The number of vCores. Allowed values: 8, 16, 24, 32, 40, 64, 80.
+        """
+        return pulumi.get(self, "v_cores")
+
+    @property
+    @pulumi.getter(name="virtualClusterId")
+    def virtual_cluster_id(self) -> str:
+        """
+        Virtual cluster resource id for the Managed Instance.
+        """
+        return pulumi.get(self, "virtual_cluster_id")
+
+    @property
+    @pulumi.getter(name="zoneRedundant")
+    def zone_redundant(self) -> Optional[bool]:
+        """
+        Whether or not the multi-az is enabled.
+        """
+        return pulumi.get(self, "zone_redundant")
+
+
+class AwaitableGetManagedInstanceResult(GetManagedInstanceResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetManagedInstanceResult(
+            administrator_login=self.administrator_login,
+            administrators=self.administrators,
+            authentication_metadata=self.authentication_metadata,
+            collation=self.collation,
+            create_time=self.create_time,
+            current_backup_storage_redundancy=self.current_backup_storage_redundancy,
+            database_format=self.database_format,
+            dns_zone=self.dns_zone,
+            external_governance_status=self.external_governance_status,
+            fully_qualified_domain_name=self.fully_qualified_domain_name,
+            hybrid_secondary_usage=self.hybrid_secondary_usage,
+            hybrid_secondary_usage_detected=self.hybrid_secondary_usage_detected,
+            id=self.id,
+            identity=self.identity,
+            instance_pool_id=self.instance_pool_id,
+            is_general_purpose_v2=self.is_general_purpose_v2,
+            key_id=self.key_id,
+            license_type=self.license_type,
+            location=self.location,
+            maintenance_configuration_id=self.maintenance_configuration_id,
+            minimal_tls_version=self.minimal_tls_version,
+            name=self.name,
+            pricing_model=self.pricing_model,
+            primary_user_assigned_identity_id=self.primary_user_assigned_identity_id,
+            private_endpoint_connections=self.private_endpoint_connections,
+            provisioning_state=self.provisioning_state,
+            proxy_override=self.proxy_override,
+            public_data_endpoint_enabled=self.public_data_endpoint_enabled,
+            requested_backup_storage_redundancy=self.requested_backup_storage_redundancy,
+            service_principal=self.service_principal,
+            sku=self.sku,
+            state=self.state,
+            storage_i_ops=self.storage_i_ops,
+            storage_size_in_gb=self.storage_size_in_gb,
+            storage_throughput_m_bps=self.storage_throughput_m_bps,
+            subnet_id=self.subnet_id,
+            tags=self.tags,
+            timezone_id=self.timezone_id,
+            total_memory_mb=self.total_memory_mb,
+            type=self.type,
+            v_cores=self.v_cores,
+            virtual_cluster_id=self.virtual_cluster_id,
+            zone_redundant=self.zone_redundant)
+
+
+def get_managed_instance(expand: Optional[str] = None,
+                         managed_instance_name: Optional[str] = None,
+                         resource_group_name: Optional[str] = None,
+                         opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetManagedInstanceResult:
+    """
+    Gets a managed instance.
+
+
+    :param str expand: The child resources to include in the response.
+    :param str managed_instance_name: The name of the managed instance.
+    :param str resource_group_name: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal.
+    """
+    __args__ = dict()
+    __args__['expand'] = expand
+    __args__['managedInstanceName'] = managed_instance_name
+    __args__['resourceGroupName'] = resource_group_name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('azure-native:sql/v20240501preview:getManagedInstance', __args__, opts=opts, typ=GetManagedInstanceResult).value
+
+    return AwaitableGetManagedInstanceResult(
+        administrator_login=pulumi.get(__ret__, 'administrator_login'),
+        administrators=pulumi.get(__ret__, 'administrators'),
+        authentication_metadata=pulumi.get(__ret__, 'authentication_metadata'),
+        collation=pulumi.get(__ret__, 'collation'),
+        create_time=pulumi.get(__ret__, 'create_time'),
+        current_backup_storage_redundancy=pulumi.get(__ret__, 'current_backup_storage_redundancy'),
+        database_format=pulumi.get(__ret__, 'database_format'),
+        dns_zone=pulumi.get(__ret__, 'dns_zone'),
+        external_governance_status=pulumi.get(__ret__, 'external_governance_status'),
+        fully_qualified_domain_name=pulumi.get(__ret__, 'fully_qualified_domain_name'),
+        hybrid_secondary_usage=pulumi.get(__ret__, 'hybrid_secondary_usage'),
+        hybrid_secondary_usage_detected=pulumi.get(__ret__, 'hybrid_secondary_usage_detected'),
+        id=pulumi.get(__ret__, 'id'),
+        identity=pulumi.get(__ret__, 'identity'),
+        instance_pool_id=pulumi.get(__ret__, 'instance_pool_id'),
+        is_general_purpose_v2=pulumi.get(__ret__, 'is_general_purpose_v2'),
+        key_id=pulumi.get(__ret__, 'key_id'),
+        license_type=pulumi.get(__ret__, 'license_type'),
+        location=pulumi.get(__ret__, 'location'),
+        maintenance_configuration_id=pulumi.get(__ret__, 'maintenance_configuration_id'),
+        minimal_tls_version=pulumi.get(__ret__, 'minimal_tls_version'),
+        name=pulumi.get(__ret__, 'name'),
+        pricing_model=pulumi.get(__ret__, 'pricing_model'),
+        primary_user_assigned_identity_id=pulumi.get(__ret__, 'primary_user_assigned_identity_id'),
+        private_endpoint_connections=pulumi.get(__ret__, 'private_endpoint_connections'),
+        provisioning_state=pulumi.get(__ret__, 'provisioning_state'),
+        proxy_override=pulumi.get(__ret__, 'proxy_override'),
+        public_data_endpoint_enabled=pulumi.get(__ret__, 'public_data_endpoint_enabled'),
+        requested_backup_storage_redundancy=pulumi.get(__ret__, 'requested_backup_storage_redundancy'),
+        service_principal=pulumi.get(__ret__, 'service_principal'),
+        sku=pulumi.get(__ret__, 'sku'),
+        state=pulumi.get(__ret__, 'state'),
+        storage_i_ops=pulumi.get(__ret__, 'storage_i_ops'),
+        storage_size_in_gb=pulumi.get(__ret__, 'storage_size_in_gb'),
+        storage_throughput_m_bps=pulumi.get(__ret__, 'storage_throughput_m_bps'),
+        subnet_id=pulumi.get(__ret__, 'subnet_id'),
+        tags=pulumi.get(__ret__, 'tags'),
+        timezone_id=pulumi.get(__ret__, 'timezone_id'),
+        total_memory_mb=pulumi.get(__ret__, 'total_memory_mb'),
+        type=pulumi.get(__ret__, 'type'),
+        v_cores=pulumi.get(__ret__, 'v_cores'),
+        virtual_cluster_id=pulumi.get(__ret__, 'virtual_cluster_id'),
+        zone_redundant=pulumi.get(__ret__, 'zone_redundant'))
+
+
+@_utilities.lift_output_func(get_managed_instance)
+def get_managed_instance_output(expand: Optional[pulumi.Input[Optional[str]]] = None,
+                                managed_instance_name: Optional[pulumi.Input[str]] = None,
+                                resource_group_name: Optional[pulumi.Input[str]] = None,
+                                opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetManagedInstanceResult]:
+    """
+    Gets a managed instance.
+
+
+    :param str expand: The child resources to include in the response.
+    :param str managed_instance_name: The name of the managed instance.
+    :param str resource_group_name: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal.
+    """
+    ...