pulumi-azure-native 2.68.0a1729519840__py3-none-any.whl → 2.68.0a1729615467__py3-none-any.whl

pulumi_azure_native/cache/v20241101/get_redis.py

@@ -0,0 +1,493 @@
+# 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__ = [
+    'GetRedisResult',
+    'AwaitableGetRedisResult',
+    'get_redis',
+    'get_redis_output',
+]
+
+@pulumi.output_type
+class GetRedisResult:
+    """
+    A single Redis item in List or Get Operation.
+    """
+    def __init__(__self__, access_keys=None, disable_access_key_authentication=None, enable_non_ssl_port=None, host_name=None, id=None, identity=None, instances=None, linked_servers=None, location=None, minimum_tls_version=None, name=None, port=None, private_endpoint_connections=None, provisioning_state=None, public_network_access=None, redis_configuration=None, redis_version=None, replicas_per_master=None, replicas_per_primary=None, shard_count=None, sku=None, ssl_port=None, static_ip=None, subnet_id=None, tags=None, tenant_settings=None, type=None, update_channel=None, zonal_allocation_policy=None, zones=None):
+        if access_keys and not isinstance(access_keys, dict):
+            raise TypeError("Expected argument 'access_keys' to be a dict")
+        pulumi.set(__self__, "access_keys", access_keys)
+        if disable_access_key_authentication and not isinstance(disable_access_key_authentication, bool):
+            raise TypeError("Expected argument 'disable_access_key_authentication' to be a bool")
+        pulumi.set(__self__, "disable_access_key_authentication", disable_access_key_authentication)
+        if enable_non_ssl_port and not isinstance(enable_non_ssl_port, bool):
+            raise TypeError("Expected argument 'enable_non_ssl_port' to be a bool")
+        pulumi.set(__self__, "enable_non_ssl_port", enable_non_ssl_port)
+        if host_name and not isinstance(host_name, str):
+            raise TypeError("Expected argument 'host_name' to be a str")
+        pulumi.set(__self__, "host_name", host_name)
+        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 instances and not isinstance(instances, list):
+            raise TypeError("Expected argument 'instances' to be a list")
+        pulumi.set(__self__, "instances", instances)
+        if linked_servers and not isinstance(linked_servers, list):
+            raise TypeError("Expected argument 'linked_servers' to be a list")
+        pulumi.set(__self__, "linked_servers", linked_servers)
+        if location and not isinstance(location, str):
+            raise TypeError("Expected argument 'location' to be a str")
+        pulumi.set(__self__, "location", location)
+        if minimum_tls_version and not isinstance(minimum_tls_version, str):
+            raise TypeError("Expected argument 'minimum_tls_version' to be a str")
+        pulumi.set(__self__, "minimum_tls_version", minimum_tls_version)
+        if name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", name)
+        if port and not isinstance(port, int):
+            raise TypeError("Expected argument 'port' to be a int")
+        pulumi.set(__self__, "port", port)
+        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 public_network_access and not isinstance(public_network_access, str):
+            raise TypeError("Expected argument 'public_network_access' to be a str")
+        pulumi.set(__self__, "public_network_access", public_network_access)
+        if redis_configuration and not isinstance(redis_configuration, dict):
+            raise TypeError("Expected argument 'redis_configuration' to be a dict")
+        pulumi.set(__self__, "redis_configuration", redis_configuration)
+        if redis_version and not isinstance(redis_version, str):
+            raise TypeError("Expected argument 'redis_version' to be a str")
+        pulumi.set(__self__, "redis_version", redis_version)
+        if replicas_per_master and not isinstance(replicas_per_master, int):
+            raise TypeError("Expected argument 'replicas_per_master' to be a int")
+        pulumi.set(__self__, "replicas_per_master", replicas_per_master)
+        if replicas_per_primary and not isinstance(replicas_per_primary, int):
+            raise TypeError("Expected argument 'replicas_per_primary' to be a int")
+        pulumi.set(__self__, "replicas_per_primary", replicas_per_primary)
+        if shard_count and not isinstance(shard_count, int):
+            raise TypeError("Expected argument 'shard_count' to be a int")
+        pulumi.set(__self__, "shard_count", shard_count)
+        if sku and not isinstance(sku, dict):
+            raise TypeError("Expected argument 'sku' to be a dict")
+        pulumi.set(__self__, "sku", sku)
+        if ssl_port and not isinstance(ssl_port, int):
+            raise TypeError("Expected argument 'ssl_port' to be a int")
+        pulumi.set(__self__, "ssl_port", ssl_port)
+        if static_ip and not isinstance(static_ip, str):
+            raise TypeError("Expected argument 'static_ip' to be a str")
+        pulumi.set(__self__, "static_ip", static_ip)
+        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 tenant_settings and not isinstance(tenant_settings, dict):
+            raise TypeError("Expected argument 'tenant_settings' to be a dict")
+        pulumi.set(__self__, "tenant_settings", tenant_settings)
+        if type and not isinstance(type, str):
+            raise TypeError("Expected argument 'type' to be a str")
+        pulumi.set(__self__, "type", type)
+        if update_channel and not isinstance(update_channel, str):
+            raise TypeError("Expected argument 'update_channel' to be a str")
+        pulumi.set(__self__, "update_channel", update_channel)
+        if zonal_allocation_policy and not isinstance(zonal_allocation_policy, str):
+            raise TypeError("Expected argument 'zonal_allocation_policy' to be a str")
+        pulumi.set(__self__, "zonal_allocation_policy", zonal_allocation_policy)
+        if zones and not isinstance(zones, list):
+            raise TypeError("Expected argument 'zones' to be a list")
+        pulumi.set(__self__, "zones", zones)
+
+    @property
+    @pulumi.getter(name="accessKeys")
+    def access_keys(self) -> 'outputs.RedisAccessKeysResponse':
+        """
+        The keys of the Redis cache - not set if this object is not the response to Create or Update redis cache
+        """
+        return pulumi.get(self, "access_keys")
+
+    @property
+    @pulumi.getter(name="disableAccessKeyAuthentication")
+    def disable_access_key_authentication(self) -> Optional[bool]:
+        """
+        Authentication to Redis through access keys is disabled when set as true. Default value is false.
+        """
+        return pulumi.get(self, "disable_access_key_authentication")
+
+    @property
+    @pulumi.getter(name="enableNonSslPort")
+    def enable_non_ssl_port(self) -> Optional[bool]:
+        """
+        Specifies whether the non-ssl Redis server port (6379) is enabled.
+        """
+        return pulumi.get(self, "enable_non_ssl_port")
+
+    @property
+    @pulumi.getter(name="hostName")
+    def host_name(self) -> str:
+        """
+        Redis host name.
+        """
+        return pulumi.get(self, "host_name")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def identity(self) -> Optional['outputs.ManagedServiceIdentityResponse']:
+        """
+        The identity of the resource.
+        """
+        return pulumi.get(self, "identity")
+
+    @property
+    @pulumi.getter
+    def instances(self) -> Sequence['outputs.RedisInstanceDetailsResponse']:
+        """
+        List of the Redis instances associated with the cache
+        """
+        return pulumi.get(self, "instances")
+
+    @property
+    @pulumi.getter(name="linkedServers")
+    def linked_servers(self) -> Sequence['outputs.RedisLinkedServerResponse']:
+        """
+        List of the linked servers associated with the cache
+        """
+        return pulumi.get(self, "linked_servers")
+
+    @property
+    @pulumi.getter
+    def location(self) -> str:
+        """
+        The geo-location where the resource lives
+        """
+        return pulumi.get(self, "location")
+
+    @property
+    @pulumi.getter(name="minimumTlsVersion")
+    def minimum_tls_version(self) -> Optional[str]:
+        """
+        Optional: requires clients to use a specified TLS version (or higher) to connect (e,g, '1.0', '1.1', '1.2')
+        """
+        return pulumi.get(self, "minimum_tls_version")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of the resource
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def port(self) -> int:
+        """
+        Redis non-SSL port.
+        """
+        return pulumi.get(self, "port")
+
+    @property
+    @pulumi.getter(name="privateEndpointConnections")
+    def private_endpoint_connections(self) -> Sequence['outputs.PrivateEndpointConnectionResponse']:
+        """
+        List of private endpoint connection associated with the specified redis cache
+        """
+        return pulumi.get(self, "private_endpoint_connections")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> str:
+        """
+        Redis instance provisioning status.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="publicNetworkAccess")
+    def public_network_access(self) -> Optional[str]:
+        """
+        Whether or not public endpoint access is allowed for this cache.  Value is optional but if passed in, must be 'Enabled' or 'Disabled'. If 'Disabled', private endpoints are the exclusive access method. Default value is 'Enabled'
+        """
+        return pulumi.get(self, "public_network_access")
+
+    @property
+    @pulumi.getter(name="redisConfiguration")
+    def redis_configuration(self) -> Optional['outputs.RedisCommonPropertiesResponseRedisConfiguration']:
+        """
+        All Redis Settings. Few possible keys: rdb-backup-enabled,rdb-storage-connection-string,rdb-backup-frequency,maxmemory-delta, maxmemory-policy,notify-keyspace-events, aof-backup-enabled, aof-storage-connection-string-0, aof-storage-connection-string-1 etc.
+        """
+        return pulumi.get(self, "redis_configuration")
+
+    @property
+    @pulumi.getter(name="redisVersion")
+    def redis_version(self) -> Optional[str]:
+        """
+        Redis version. This should be in the form 'major[.minor]' (only 'major' is required) or the value 'latest' which refers to the latest stable Redis version that is available. Supported versions: 4.0, 6.0 (latest). Default value is 'latest'.
+        """
+        return pulumi.get(self, "redis_version")
+
+    @property
+    @pulumi.getter(name="replicasPerMaster")
+    def replicas_per_master(self) -> Optional[int]:
+        """
+        The number of replicas to be created per primary.
+        """
+        return pulumi.get(self, "replicas_per_master")
+
+    @property
+    @pulumi.getter(name="replicasPerPrimary")
+    def replicas_per_primary(self) -> Optional[int]:
+        """
+        The number of replicas to be created per primary.
+        """
+        return pulumi.get(self, "replicas_per_primary")
+
+    @property
+    @pulumi.getter(name="shardCount")
+    def shard_count(self) -> Optional[int]:
+        """
+        The number of shards to be created on a Premium Cluster Cache.
+        """
+        return pulumi.get(self, "shard_count")
+
+    @property
+    @pulumi.getter
+    def sku(self) -> 'outputs.SkuResponse':
+        """
+        The SKU of the Redis cache to deploy.
+        """
+        return pulumi.get(self, "sku")
+
+    @property
+    @pulumi.getter(name="sslPort")
+    def ssl_port(self) -> int:
+        """
+        Redis SSL port.
+        """
+        return pulumi.get(self, "ssl_port")
+
+    @property
+    @pulumi.getter(name="staticIP")
+    def static_ip(self) -> Optional[str]:
+        """
+        Static IP address. Optionally, may be specified when deploying a Redis cache inside an existing Azure Virtual Network; auto assigned by default.
+        """
+        return pulumi.get(self, "static_ip")
+
+    @property
+    @pulumi.getter(name="subnetId")
+    def subnet_id(self) -> Optional[str]:
+        """
+        The full resource ID of a subnet in a virtual network to deploy the Redis cache in. Example format: /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/Microsoft.{Network|ClassicNetwork}/VirtualNetworks/vnet1/subnets/subnet1
+        """
+        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="tenantSettings")
+    def tenant_settings(self) -> Optional[Mapping[str, str]]:
+        """
+        A dictionary of tenant settings
+        """
+        return pulumi.get(self, "tenant_settings")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="updateChannel")
+    def update_channel(self) -> Optional[str]:
+        """
+        Optional: Specifies the update channel for the monthly Redis updates your Redis Cache will receive. Caches using 'Preview' update channel get latest Redis updates at least 4 weeks ahead of 'Stable' channel caches. Default value is 'Stable'.
+        """
+        return pulumi.get(self, "update_channel")
+
+    @property
+    @pulumi.getter(name="zonalAllocationPolicy")
+    def zonal_allocation_policy(self) -> Optional[str]:
+        """
+        Optional: Specifies how availability zones are allocated to the Redis cache. 'Automatic' enables zone redundancy and Azure will automatically select zones based on regional availability and capacity. 'UserDefined' will select availability zones passed in by you using the 'zones' parameter. 'NoZones' will produce a non-zonal cache. If 'zonalAllocationPolicy' is not passed, it will be set to 'UserDefined' when zones are passed in, otherwise, it will be set to 'Automatic' in regions where zones are supported and 'NoZones' in regions where zones are not supported.
+        """
+        return pulumi.get(self, "zonal_allocation_policy")
+
+    @property
+    @pulumi.getter
+    def zones(self) -> Optional[Sequence[str]]:
+        """
+        A list of availability zones denoting where the resource needs to come from.
+        """
+        return pulumi.get(self, "zones")
+
+
+class AwaitableGetRedisResult(GetRedisResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetRedisResult(
+            access_keys=self.access_keys,
+            disable_access_key_authentication=self.disable_access_key_authentication,
+            enable_non_ssl_port=self.enable_non_ssl_port,
+            host_name=self.host_name,
+            id=self.id,
+            identity=self.identity,
+            instances=self.instances,
+            linked_servers=self.linked_servers,
+            location=self.location,
+            minimum_tls_version=self.minimum_tls_version,
+            name=self.name,
+            port=self.port,
+            private_endpoint_connections=self.private_endpoint_connections,
+            provisioning_state=self.provisioning_state,
+            public_network_access=self.public_network_access,
+            redis_configuration=self.redis_configuration,
+            redis_version=self.redis_version,
+            replicas_per_master=self.replicas_per_master,
+            replicas_per_primary=self.replicas_per_primary,
+            shard_count=self.shard_count,
+            sku=self.sku,
+            ssl_port=self.ssl_port,
+            static_ip=self.static_ip,
+            subnet_id=self.subnet_id,
+            tags=self.tags,
+            tenant_settings=self.tenant_settings,
+            type=self.type,
+            update_channel=self.update_channel,
+            zonal_allocation_policy=self.zonal_allocation_policy,
+            zones=self.zones)
+
+
+def get_redis(name: Optional[str] = None,
+              resource_group_name: Optional[str] = None,
+              opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetRedisResult:
+    """
+    Gets a Redis cache (resource description).
+
+
+    :param str name: The name of the Redis cache.
+    :param str resource_group_name: The name of the resource group. The name is case insensitive.
+    """
+    __args__ = dict()
+    __args__['name'] = name
+    __args__['resourceGroupName'] = resource_group_name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('azure-native:cache/v20241101:getRedis', __args__, opts=opts, typ=GetRedisResult).value
+
+    return AwaitableGetRedisResult(
+        access_keys=pulumi.get(__ret__, 'access_keys'),
+        disable_access_key_authentication=pulumi.get(__ret__, 'disable_access_key_authentication'),
+        enable_non_ssl_port=pulumi.get(__ret__, 'enable_non_ssl_port'),
+        host_name=pulumi.get(__ret__, 'host_name'),
+        id=pulumi.get(__ret__, 'id'),
+        identity=pulumi.get(__ret__, 'identity'),
+        instances=pulumi.get(__ret__, 'instances'),
+        linked_servers=pulumi.get(__ret__, 'linked_servers'),
+        location=pulumi.get(__ret__, 'location'),
+        minimum_tls_version=pulumi.get(__ret__, 'minimum_tls_version'),
+        name=pulumi.get(__ret__, 'name'),
+        port=pulumi.get(__ret__, 'port'),
+        private_endpoint_connections=pulumi.get(__ret__, 'private_endpoint_connections'),
+        provisioning_state=pulumi.get(__ret__, 'provisioning_state'),
+        public_network_access=pulumi.get(__ret__, 'public_network_access'),
+        redis_configuration=pulumi.get(__ret__, 'redis_configuration'),
+        redis_version=pulumi.get(__ret__, 'redis_version'),
+        replicas_per_master=pulumi.get(__ret__, 'replicas_per_master'),
+        replicas_per_primary=pulumi.get(__ret__, 'replicas_per_primary'),
+        shard_count=pulumi.get(__ret__, 'shard_count'),
+        sku=pulumi.get(__ret__, 'sku'),
+        ssl_port=pulumi.get(__ret__, 'ssl_port'),
+        static_ip=pulumi.get(__ret__, 'static_ip'),
+        subnet_id=pulumi.get(__ret__, 'subnet_id'),
+        tags=pulumi.get(__ret__, 'tags'),
+        tenant_settings=pulumi.get(__ret__, 'tenant_settings'),
+        type=pulumi.get(__ret__, 'type'),
+        update_channel=pulumi.get(__ret__, 'update_channel'),
+        zonal_allocation_policy=pulumi.get(__ret__, 'zonal_allocation_policy'),
+        zones=pulumi.get(__ret__, 'zones'))
+def get_redis_output(name: Optional[pulumi.Input[str]] = None,
+                     resource_group_name: Optional[pulumi.Input[str]] = None,
+                     opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetRedisResult]:
+    """
+    Gets a Redis cache (resource description).
+
+
+    :param str name: The name of the Redis cache.
+    :param str resource_group_name: The name of the resource group. The name is case insensitive.
+    """
+    __args__ = dict()
+    __args__['name'] = name
+    __args__['resourceGroupName'] = resource_group_name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('azure-native:cache/v20241101:getRedis', __args__, opts=opts, typ=GetRedisResult)
+    return __ret__.apply(lambda __response__: GetRedisResult(
+        access_keys=pulumi.get(__response__, 'access_keys'),
+        disable_access_key_authentication=pulumi.get(__response__, 'disable_access_key_authentication'),
+        enable_non_ssl_port=pulumi.get(__response__, 'enable_non_ssl_port'),
+        host_name=pulumi.get(__response__, 'host_name'),
+        id=pulumi.get(__response__, 'id'),
+        identity=pulumi.get(__response__, 'identity'),
+        instances=pulumi.get(__response__, 'instances'),
+        linked_servers=pulumi.get(__response__, 'linked_servers'),
+        location=pulumi.get(__response__, 'location'),
+        minimum_tls_version=pulumi.get(__response__, 'minimum_tls_version'),
+        name=pulumi.get(__response__, 'name'),
+        port=pulumi.get(__response__, 'port'),
+        private_endpoint_connections=pulumi.get(__response__, 'private_endpoint_connections'),
+        provisioning_state=pulumi.get(__response__, 'provisioning_state'),
+        public_network_access=pulumi.get(__response__, 'public_network_access'),
+        redis_configuration=pulumi.get(__response__, 'redis_configuration'),
+        redis_version=pulumi.get(__response__, 'redis_version'),
+        replicas_per_master=pulumi.get(__response__, 'replicas_per_master'),
+        replicas_per_primary=pulumi.get(__response__, 'replicas_per_primary'),
+        shard_count=pulumi.get(__response__, 'shard_count'),
+        sku=pulumi.get(__response__, 'sku'),
+        ssl_port=pulumi.get(__response__, 'ssl_port'),
+        static_ip=pulumi.get(__response__, 'static_ip'),
+        subnet_id=pulumi.get(__response__, 'subnet_id'),
+        tags=pulumi.get(__response__, 'tags'),
+        tenant_settings=pulumi.get(__response__, 'tenant_settings'),
+        type=pulumi.get(__response__, 'type'),
+        update_channel=pulumi.get(__response__, 'update_channel'),
+        zonal_allocation_policy=pulumi.get(__response__, 'zonal_allocation_policy'),
+        zones=pulumi.get(__response__, 'zones')))