pulumi-django-azure 1.0.34__py3-none-any.whl → 1.0.35__py3-none-any.whl

pulumi_django_azure/azure_helper.py

@@ -2,7 +2,9 @@ import base64
 import json
 import logging
 import os
+import time
 from dataclasses import dataclass
+from enum import Enum
 from subprocess import check_output
 
 from azure.identity import DefaultAzureCredential
@@ -15,6 +17,9 @@ logger = logging.getLogger("pulumi_django_azure.azure_helper")
 # Azure credentials
 AZURE_CREDENTIAL = DefaultAzureCredential()
 
+# Buffer for token expiration (5 minutes)
+TOKEN_EXPIRATION_BUFFER = 300
+
 # Get the local IP addresses of the machine (only when runnig on Azure)
 if os.environ.get("IS_AZURE_ENVIRONMENT"):
     LOCAL_IP_ADDRESSES = check_output(["hostname", "--all-ip-addresses"]).decode("utf-8").strip().split(" ")
@@ -22,17 +27,44 @@ else:
     LOCAL_IP_ADDRESSES = []
 
 
-def get_db_password() -> str:
+class TokenType(Enum):
+    DATABASE = "https://ossrdbms-aad.database.windows.net/.default"
+    REDIS = "https://redis.azure.com/.default"
+
+
+def _get_azure_token(type: TokenType) -> str:
     """
-    Get a valid password for the database.
+    Get a valid token for the given scope.
     """
-    token = AZURE_CREDENTIAL.get_token("https://ossrdbms-aad.database.windows.net/.default")
+    global AZURE_CREDENTIAL
+
+    token = AZURE_CREDENTIAL.get_token(type.value)
+
+    if token.expires_on < time.time() + TOKEN_EXPIRATION_BUFFER:
+        # We received an expired or nearly expired token from the API. Force a new token by creating a new instance of the credential.
+        logger.debug(
+            "Received an expired or nearly expired %s token (current time: %s, token expiration: %s)."
+            "Creating a new instance of the credential.",
+            type.name,
+            time.time(),
+            token.expires_on,
+        )
+
+        AZURE_CREDENTIAL = DefaultAzureCredential()
+        token = AZURE_CREDENTIAL.get_token(type.value)
 
-    logger.debug("New database token: %s", token)
+        logger.debug("New %s token (try 2): %s", type.name, token)
 
     return token.token
 
 
+def get_db_password() -> str:
+    """
+    Get a valid password for the database.
+    """
+    return _get_azure_token(TokenType.DATABASE)
+
+
 @dataclass
 class RedisCredentials:
     username: str
@@ -43,11 +75,9 @@ def get_redis_credentials() -> RedisCredentials:
     """
     Get valid credentials for the Redis cache.
     """
-    token = AZURE_CREDENTIAL.get_token("https://redis.azure.com/.default")
-
-    logger.debug("New Redis token: %s", token)
+    token = _get_azure_token(TokenType.REDIS)
 
-    return RedisCredentials(_extract_username_from_token(token.token), token.token)
+    return RedisCredentials(_extract_username_from_token(token), token)
 
 
 def get_subscription() -> Subscription:

pulumi_django_azure/django_deployment.py

@@ -4,6 +4,8 @@ import pulumi
 import pulumi_azure_native as azure
 import pulumi_random
 
+REDIS_IMAGE = "redis:8.2"
+
 
 class HostDefinition:
     """
@@ -71,8 +73,6 @@ class DjangoDeployment(pulumi.ComponentResource):
         pgsql_parameters: dict[str, str] | None = None,
         pgadmin_access_ip: Sequence[str] | None = None,
         pgadmin_dns_zone: azure.dns.Zone | None = None,
-        cache_ip_prefix: str | None = None,
-        cache_sku: azure.redis.SkuArgs | None = None,
         cdn_host: HostDefinition | None = None,
         opts=None,
     ):
@@ -92,8 +92,6 @@ class DjangoDeployment(pulumi.ComponentResource):
         :param pgsql_parameters: The parameters to set on the PostgreSQL server. (optional)
         :param pgadmin_access_ip: The IP addresses to allow access to pgAdmin. If empty, all IP addresses are allowed.
         :param pgadmin_dns_zone: The Azure DNS zone to a pgadmin DNS record in. (optional)
-        :param cache_ip_prefix: The IP prefix for the cache subnet. (optional)
-        :param cache_sku: The SKU for the cache. (optional)
         :param cdn_host: A custom CDN host name. (optional)
         :param opts: The resource options
         """
@@ -115,12 +113,6 @@ class DjangoDeployment(pulumi.ComponentResource):
         # PostgreSQL resources
         self._create_database(sku=pgsql_sku, ip_prefix=pgsql_ip_prefix, parameters=pgsql_parameters)
 
-        # Cache resources
-        if cache_ip_prefix and cache_sku:
-            self._create_cache(sku=cache_sku, ip_prefix=cache_ip_prefix)
-        else:
-            self._cache = None
-
         # Subnet for the apps
         self._app_subnet = self._create_subnet(
             name="app-service",
@@ -325,91 +317,6 @@ class DjangoDeployment(pulumi.ComponentResource):
 
         pulumi.export("pgsql_host", self._pgsql.fully_qualified_domain_name)
 
-    def _create_cache(self, sku: azure.redis.SkuArgs, ip_prefix: str):
-        # Create a Redis cache
-        self._cache = azure.redis.Redis(
-            f"cache-{self._name}",
-            resource_group_name=self._rg,
-            sku=sku,
-            enable_non_ssl_port=False,
-            public_network_access=azure.redis.PublicNetworkAccess.DISABLED,
-            # Disable access key authentication...
-            disable_access_key_authentication=True,
-            # ... and enable Entra ID authentication.
-            redis_configuration=azure.redis.RedisCommonPropertiesRedisConfigurationArgs(
-                aad_enabled="true",
-            ),
-        )
-
-        # Create an access policy that gives us access to the cache
-        self._cache_access_policy = azure.redis.AccessPolicy(
-            f"cache-access-policy-{self._name}",
-            resource_group_name=self._rg,
-            cache_name=self._cache.name,
-            # Same as the built in Data Contributor policy + flushdb permissions
-            permissions="+@all -@dangerous +flushdb +cluster|info +cluster|nodes +cluster|slots allkeys",
-        )
-
-        # Allocate a subnet for the cache
-        subnet = self._create_subnet(
-            name="cache",
-            prefix=ip_prefix,
-        )
-
-        # Create a private DNS zone for the cache
-        dns = azure.privatedns.PrivateZone(
-            f"dns-cache-{self._name}",
-            resource_group_name=self._rg,
-            location="global",
-            private_zone_name="privatelink.redis.cache.windows.net",
-        )
-
-        # Link the private DNS zone to the VNet in order to make resolving work
-        azure.privatedns.VirtualNetworkLink(
-            f"vnet-link-cache-{self._name}",
-            resource_group_name=self._rg,
-            location="global",
-            private_zone_name=dns.name,
-            virtual_network=azure.network.SubResourceArgs(id=self._vnet.id),
-            registration_enabled=True,
-        )
-
-        # Create a private endpoint for the cache
-        endpoint = azure.network.PrivateEndpoint(
-            f"private-endpoint-cache-{self._name}",
-            resource_group_name=self._rg,
-            subnet=azure.network.SubnetArgs(id=subnet.id),
-            custom_network_interface_name=f"nic-cache-{self._name}",
-            private_link_service_connections=[
-                azure.network.PrivateLinkServiceConnectionArgs(
-                    name=f"pls-cache-{self._name}",
-                    private_link_service_id=self._cache.id,
-                    group_ids=["redisCache"],
-                )
-            ],
-        )
-
-        # Get the private IP address of the endpoint NIC
-        ip = endpoint.network_interfaces.apply(
-            lambda nics: azure.network.get_network_interface(
-                network_interface_name=nics[0].id.split("/")[-1],
-                resource_group_name=self._rg,
-            )
-            .ip_configurations[0]
-            .private_ip_address
-        )
-
-        # Create a DNS record for the cache
-        azure.privatedns.PrivateRecordSet(
-            f"dns-a-cache-{self._name}",
-            resource_group_name=self._rg,
-            private_zone_name=dns.name,
-            relative_record_set_name=self._cache.name,
-            record_type="A",
-            ttl=300,
-            a_records=[azure.privatedns.ARecordArgs(ipv4_address=ip)],
-        )
-
     def _create_subnet(
         self,
         name,
@@ -866,7 +773,7 @@ class DjangoDeployment(pulumi.ComponentResource):
         comms_domains: list[HostDefinition] | None = None,
         dedicated_app_service_sku: azure.web.SkuDescriptionArgs | None = None,
         vault_administrators: list[str] | None = None,
-        cache_db: int | None = None,
+        redis_cache: bool = True,
         startup_timeout: int = 300,
     ) -> azure.web.WebApp:
         """
@@ -887,7 +794,7 @@ class DjangoDeployment(pulumi.ComponentResource):
         :param comms_domains: The list of custom domains for the E-mail Communication Services (optional).
         :param dedicated_app_service_sku: The SKU for the dedicated App Service Plan (optional).
         :param vault_administrators: The principal IDs of the vault administrators (optional).
-        :param cache_db: The index of the cache database to use (optional).
+        :param redis_cache: Whether to create a Redis sidecar container.
         :param startup_timeout: The startup timeout for the App Service (default is 300 seconds).
         """
 
@@ -917,6 +824,10 @@ class DjangoDeployment(pulumi.ComponentResource):
             container_name=f"{name}-static",
         )
 
+        # Redis cache environment variable
+        if redis_cache:
+            environment_variables["REDIS_SIDECAR"] = "true"
+
         # Communication Services (optional)
         if comms_data_location:
             if not comms_domains:
@@ -937,12 +848,6 @@ class DjangoDeployment(pulumi.ComponentResource):
             s = self._add_webapp_secret(vault, env_name, config_name, f"{name}-{self._name}")
             environment_variables[f"{env_name}_SECRET_NAME"] = s.name
 
-        # Cache (we need to check explicitly if it is not None because the db could also be 0)
-        if self._cache and cache_db is not None:
-            environment_variables["REDIS_CACHE_HOST"] = self._cache.host_name
-            environment_variables["REDIS_CACHE_PORT"] = self._cache.ssl_port.apply(lambda port: str(port))
-            environment_variables["REDIS_CACHE_DB"] = str(cache_db)
-
         # Create a Django Secret Key (random)
         secret_key = pulumi_random.RandomString(f"django-secret-{name}-{self._name}", length=50)
 
@@ -1023,6 +928,18 @@ class DjangoDeployment(pulumi.ComponentResource):
             ),
         )
 
+        # Redis cache
+        if redis_cache:
+            azure.web.WebAppSiteContainer(
+                f"redis-cache-{name}-{self._name}",
+                resource_group_name=self._rg,
+                name=app.name,
+                is_main=False,
+                container_name="redis-cache",
+                image=REDIS_IMAGE,
+                target_port="6379",
+            )
+
         # We need this to create the database role and grant permissions
         principal_id = app.identity.apply(lambda identity: identity.principal_id)
         pulumi.export(f"{name}_site_principal_id", principal_id)
@@ -1148,18 +1065,6 @@ class DjangoDeployment(pulumi.ComponentResource):
             scope=self._storage_account.id,
         )
 
-        # Grant the app access to the cache if needed.
-        # We need to check explicitly if it is not None because the db could also be 0.
-        if self._cache and cache_db is not None:
-            azure.redis.AccessPolicyAssignment(
-                f"ra-{name}-cache",
-                resource_group_name=self._rg,
-                cache_name=self._cache.name,
-                object_id=principal_id,
-                object_id_alias=f"app-{name}-managed-identity",
-                access_policy_name=self._cache_access_policy.name,
-            )
-
         # Grant the app to send e-mails
         if comms:
             comms_role = comms.id.apply(

pulumi_django_azure/management/commands/test_redis.py

@@ -0,0 +1,248 @@
+"""
+Management command to test Redis connectivity and functionality.
+"""
+
+import time
+
+from django.conf import settings
+from django.core.cache import cache
+from django.core.management.base import BaseCommand, CommandError
+
+
+class Command(BaseCommand):
+    help = "Test Redis connectivity and basic functionality"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--detailed",
+            action="store_true",
+            help="Show detailed Redis information and run comprehensive tests",
+        )
+        parser.add_argument(
+            "--quiet",
+            action="store_true",
+            help="Only show errors and final status",
+        )
+
+    def handle(self, *args, **options):
+        verbosity = 0 if options["quiet"] else (2 if options["detailed"] else 1)
+
+        if verbosity >= 1:
+            self.stdout.write("Testing Redis connectivity...")
+            self.stdout.write("-" * 50)
+
+        try:
+            # Test basic connectivity
+            self._test_basic_connectivity(verbosity)
+
+            # Test basic cache operations
+            self._test_cache_operations(verbosity)
+
+            # If detailed mode, run additional tests
+            if options["detailed"]:
+                self._test_detailed_operations(verbosity)
+                self._show_cache_info(verbosity)
+
+            if verbosity >= 1:
+                self.stdout.write(self.style.SUCCESS("✓ All Redis tests passed successfully!"))
+
+        except Exception as e:
+            if verbosity >= 1:
+                self.stdout.write(self.style.ERROR(f"✗ Redis test failed: {str(e)}"))
+            raise CommandError(f"Redis connectivity test failed: {str(e)}") from e
+
+    def _test_basic_connectivity(self, verbosity):
+        """Test basic Redis connectivity."""
+        if verbosity >= 2:
+            self.stdout.write("Testing basic connectivity...")
+
+        try:
+            # Try to set and get a simple value
+            cache.set("redis_test_key", "test_value", 30)
+            value = cache.get("redis_test_key")
+
+            if value != "test_value":
+                raise Exception("Failed to retrieve test value from cache")
+
+            # Clean up
+            cache.delete("redis_test_key")
+
+            if verbosity >= 2:
+                self.stdout.write(self.style.SUCCESS("  ✓ Basic connectivity test passed"))
+
+        except Exception as e:
+            raise Exception(f"Basic connectivity test failed: {str(e)}") from e
+
+    def _test_cache_operations(self, verbosity):
+        """Test various cache operations."""
+        if verbosity >= 2:
+            self.stdout.write("Testing cache operations...")
+
+        test_data = {
+            "string_test": "Hello Redis!",
+            "number_test": 42,
+            "dict_test": {"key": "value", "nested": {"data": True}},
+            "list_test": [1, 2, 3, "four", 5.0],
+        }
+
+        try:
+            # Test different data types
+            for key, value in test_data.items():
+                cache.set(f"test_{key}", value, 60)
+                retrieved_value = cache.get(f"test_{key}")
+
+                if retrieved_value != value:
+                    raise Exception(f"Data mismatch for {key}: expected {value}, got {retrieved_value}")
+
+                if verbosity >= 2:
+                    self.stdout.write(f"  ✓ {key}: {type(value).__name__} data test passed")
+
+            # Test cache.get_or_set
+            default_value = "default_from_function"
+            result = cache.get_or_set("test_get_or_set", default_value, 60)
+            if result != default_value:
+                raise Exception("get_or_set test failed")
+
+            if verbosity >= 2:
+                self.stdout.write("  ✓ get_or_set operation test passed")
+
+            # Test cache.add (should fail on existing key)
+            if cache.add("test_string_test", "should_not_override"):
+                raise Exception("add() should have failed on existing key")
+
+            if verbosity >= 2:
+                self.stdout.write("  ✓ add operation test passed")
+
+            # Test cache expiration
+            cache.set("test_expiration", "will_expire", 1)
+            time.sleep(1.1)  # Wait for expiration
+            expired_value = cache.get("test_expiration")
+            if expired_value is not None:
+                raise Exception("Cache expiration test failed - value should have expired")
+
+            if verbosity >= 2:
+                self.stdout.write("  ✓ Cache expiration test passed")
+
+            # Clean up test keys
+            for key in test_data:
+                cache.delete(f"test_{key}")
+            cache.delete("test_get_or_set")
+
+            if verbosity >= 2:
+                self.stdout.write(self.style.SUCCESS("  ✓ All cache operations tests passed"))
+
+        except Exception as e:
+            raise Exception(f"Cache operations test failed: {str(e)}") from e
+
+    def _test_detailed_operations(self, verbosity):
+        """Run detailed Redis operations tests."""
+        if verbosity >= 2:
+            self.stdout.write("Running detailed operations...")
+
+        try:
+            # Test cache.get_many and set_many
+            test_data = {
+                "bulk_key_1": "value_1",
+                "bulk_key_2": "value_2",
+                "bulk_key_3": "value_3",
+            }
+
+            cache.set_many(test_data, 60)
+            retrieved_data = cache.get_many(test_data.keys())
+
+            for key, expected_value in test_data.items():
+                if retrieved_data.get(key) != expected_value:
+                    raise Exception(f"Bulk operation failed for key {key}")
+
+            if verbosity >= 2:
+                self.stdout.write("  ✓ Bulk operations (set_many/get_many) test passed")
+
+            # Test cache.delete_many
+            cache.delete_many(test_data.keys())
+            remaining_data = cache.get_many(test_data.keys())
+            if any(remaining_data.values()):
+                raise Exception("delete_many operation failed")
+
+            if verbosity >= 2:
+                self.stdout.write("  ✓ Bulk delete (delete_many) test passed")
+
+            # Test cache versioning if supported
+            try:
+                cache.set("version_test", "version_1", 60, version=1)
+                cache.set("version_test", "version_2", 60, version=2)
+
+                v1_value = cache.get("version_test", version=1)
+                v2_value = cache.get("version_test", version=2)
+
+                if v1_value == "version_1" and v2_value == "version_2":
+                    if verbosity >= 2:
+                        self.stdout.write("  ✓ Cache versioning test passed")
+                else:
+                    if verbosity >= 2:
+                        self.stdout.write("  ! Cache versioning not supported or failed")
+
+                cache.delete("version_test", version=1)
+                cache.delete("version_test", version=2)
+
+            except Exception:
+                if verbosity >= 2:
+                    self.stdout.write("  ! Cache versioning not supported")
+
+        except Exception as e:
+            raise Exception(f"Detailed operations test failed: {str(e)}") from e
+
+    def _show_cache_info(self, verbosity):
+        """Show information about the cache configuration."""
+        if verbosity >= 2:
+            self.stdout.write("\nCache Configuration Information:")
+            self.stdout.write("-" * 35)
+
+            # Show cache backend information
+            cache_config = getattr(settings, "CACHES", {}).get("default", {})
+            backend = cache_config.get("BACKEND", "Unknown")
+            location = cache_config.get("LOCATION", "Not specified")
+
+            self.stdout.write(f"Backend: {backend}")
+            self.stdout.write(f"Location: {location}")
+
+            # Show cache options if any
+            options = cache_config.get("OPTIONS", {})
+            if options:
+                self.stdout.write("Options:")
+                for key, value in options.items():
+                    # Don't show sensitive information like passwords
+                    if "password" in key.lower() or "secret" in key.lower():
+                        value = "***hidden***"
+                    self.stdout.write(f"  {key}: {value}")
+
+            # Try to get cache stats if available
+            try:
+                if hasattr(cache, "_cache") and hasattr(cache._cache, "get_stats"):
+                    stats = cache._cache.get_stats()
+                    if stats:
+                        self.stdout.write("\nCache Statistics:")
+                        for stat_key, stat_value in stats.items():
+                            self.stdout.write(f"  {stat_key}: {stat_value}")
+            except Exception:
+                pass  # Stats not available
+
+            # Test if we can determine Redis info
+            try:
+                # Try to access Redis client directly if using django-redis
+                if hasattr(cache, "_cache") and hasattr(cache._cache, "_client"):
+                    client = cache._cache._client
+                    if hasattr(client, "connection_pool"):
+                        pool = client.connection_pool
+                        self.stdout.write("\nConnection Pool Info:")
+                        self.stdout.write(f"  Max connections: {getattr(pool, 'max_connections', 'Unknown')}")
+                        self.stdout.write(f"  Connection class: {getattr(pool, 'connection_class', 'Unknown')}")
+
+                        connection_kwargs = getattr(pool, "connection_kwargs", {})
+                        if connection_kwargs:
+                            self.stdout.write("  Connection parameters:")
+                            for key, value in connection_kwargs.items():
+                                if "password" in key.lower():
+                                    value = "***hidden***"
+                                self.stdout.write(f"    {key}: {value}")
+            except Exception:
+                pass  # Redis-specific info not available

pulumi_django_azure/middleware.py

@@ -1,14 +1,12 @@
 import logging
 import os
+import signal
 
 from django.conf import settings
-from django.core.cache import cache
 from django.db import connection
-from django.db.utils import OperationalError
 from django.http import HttpResponse
-from django_redis import get_redis_connection
 
-from .azure_helper import get_db_password, get_redis_credentials
+from .azure_helper import get_db_password
 
 logger = logging.getLogger("pulumi_django_azure.health_check")
 
@@ -18,9 +16,20 @@ class HealthCheckMiddleware:
         self.get_response = get_response
 
     def _self_heal(self):
-        # Send HUP signal to gunicorn main thread,
-        # which will trigger new workers to start.
-        os.kill(os.getppid(), 1)
+        logger.warning("Self-healing by gracefully restarting Gunicorn.")
+
+        master_pid = os.getppid()
+
+        logger.debug("Master PID: %d", master_pid)
+
+        # https://docs.gunicorn.org/en/latest/signals.html
+
+        # Reload a new master with new workers,
+        # since the application is preloaded this is the only safe way for now.
+        os.kill(master_pid, signal.SIGUSR2)
+
+        # Gracefully shutdown the current workers
+        os.kill(master_pid, signal.SIGTERM)
 
     def __call__(self, request):
         if request.path == settings.HEALTH_CHECK_PATH:
@@ -43,41 +52,15 @@ class HealthCheckMiddleware:
                     self._self_heal()
                     return HttpResponse(status=503)
 
-            # Update the Redis credentials if needed
-            if settings.AZURE_REDIS_CREDENTIALS:
-                try:
-                    current_redis_password = settings.CACHES["default"]["OPTIONS"]["PASSWORD"]
-                    redis_credentials = get_redis_credentials()
-
-                    if redis_credentials.password != current_redis_password:
-                        logger.debug("Redis password has changed, updating credentials")
-
-                        # Re-authenticate the Redis connection
-                        redis_connection = get_redis_connection("default")
-                        redis_connection.execute_command("AUTH", redis_credentials.username, redis_credentials.password)
-
-                        settings.CACHES["default"]["OPTIONS"]["PASSWORD"] = redis_credentials.password
-                    else:
-                        logger.debug("Redis password unchanged, keeping existing credentials")
-                except Exception as e:
-                    logger.error("Failed to update Redis credentials: %s", str(e))
-                    self._self_heal()
-                    return HttpResponse(status=503)
-
             try:
                 # Test the database connection
                 connection.ensure_connection()
                 logger.debug("Database connection check passed")
 
-                # Test the Redis connection
-                cache.set("health_check", "test")
-                logger.debug("Redis connection check passed")
-
                 return HttpResponse("OK")
 
             except Exception as e:
                 logger.error("Health check failed with unexpected error: %s", str(e))
-                logger.warning("Self-healing by gracefully restarting workers.")
                 self._self_heal()
                 return HttpResponse(status=503)
 

pulumi_django_azure/settings.py

@@ -1,7 +1,7 @@
 import environ
 from azure.keyvault.secrets import SecretClient
 
-from .azure_helper import AZURE_CREDENTIAL, LOCAL_IP_ADDRESSES, get_db_password, get_redis_credentials, get_subscription
+from .azure_helper import AZURE_CREDENTIAL, LOCAL_IP_ADDRESSES, get_db_password, get_subscription
 
 env = environ.Env()
 
@@ -104,7 +104,7 @@ if IS_AZURE_ENVIRONMENT:
         "disable_existing_loggers": False,
         "formatters": {
             "timestamped": {
-                "format": "{asctime} {levelname} {message}",
+                "format": "{asctime} {levelname} [p:{process:d}] [t:{thread:d}] {message}",
                 "style": "{",
             },
         },
@@ -127,42 +127,27 @@ if IS_AZURE_ENVIRONMENT:
             },
             "pulumi_django_azure": {
                 "handlers": ["file"],
-                "level": "INFO",
+                "level": "DEBUG",
                 "propagate": True,
             },
         },
     }
 
 # Redis, if enabled
-redis_cache_host = env("REDIS_CACHE_HOST", default=None)
-redis_cache_port = env("REDIS_CACHE_PORT", default=None)
-redis_cache_db = env("REDIS_CACHE_DB", default=None)
-
-if redis_cache_host and redis_cache_port and redis_cache_db:
-    # This will enable the health check to update the Redis credentials
-    AZURE_REDIS_CREDENTIALS = True
+REDIS_SIDECAR = env("REDIS_SIDECAR", default=False)
 
-    # This will prevent the website from failing if Redis is not available
+if REDIS_SIDECAR:
+    # This will prevent the website from failing if Redis is not available.
     DJANGO_REDIS_IGNORE_EXCEPTIONS = True
     DJANGO_REDIS_LOG_IGNORED_EXCEPTIONS = True
 
-    REDIS_CACHE_HOST = redis_cache_host
-    REDIS_CACHE_PORT = redis_cache_port
-    REDIS_CACHE_DB = redis_cache_db
-    redis_credentials = get_redis_credentials()
-    REDIS_USERNAME = redis_credentials.username
-    REDIS_PASSWORD = redis_credentials.password
-
     CACHES = {
         "default": {
             "BACKEND": "django_redis.cache.RedisCache",
-            "LOCATION": f"rediss://{REDIS_USERNAME}@{REDIS_CACHE_HOST}:{REDIS_CACHE_PORT}/{REDIS_CACHE_DB}",
+            "LOCATION": "redis://localhost:6379/0",
             "OPTIONS": {
                 "CLIENT_CLASS": "django_redis.client.DefaultClient",
                 "PARSER_CLASS": "redis.connection._HiredisParser",
-                "PASSWORD": REDIS_PASSWORD,
             },
         },
     }
-else:
-    AZURE_REDIS_CREDENTIALS = False

{pulumi_django_azure-1.0.34.dist-info → pulumi_django_azure-1.0.35.dist-info}/METADATA

@@ -1,243 +1,246 @@
-Metadata-Version: 2.4
-Name: pulumi-django-azure
-Version: 1.0.34
-Summary: Simply deployment of Django on Azure with Pulumi
-Author-email: Maarten Ureel <maarten@youreal.eu>
-License-Expression: MIT
-Project-URL: Homepage, https://gitlab.com/MaartenUreel/pulumi-django-azure
-Keywords: django,pulumi,azure
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Requires-Python: <3.14,>=3.11
-Description-Content-Type: text/markdown
-Requires-Dist: azure-identity<2.0.0,>=1.21.0
-Requires-Dist: azure-keyvault-secrets<5.0.0,>=4.9.0
-Requires-Dist: azure-mgmt-cdn<14.0.0,>=13.1.1
-Requires-Dist: azure-mgmt-resource<24.0.0,>=23.3.0
-Requires-Dist: django<6.0,>=5.2
-Requires-Dist: django-azure-communication-email<2.0.0,>=1.3.2
-Requires-Dist: django-environ<0.13.0,>=0.12.0
-Requires-Dist: django-redis<6.0.0,>=5.4.0
-Requires-Dist: django-storages[azure]<2.0.0,>=1.14.6
-Requires-Dist: pulumi>=3.166.0
-Requires-Dist: pulumi-azure-native>=3.2.0
-Requires-Dist: pulumi-random>=4.18.2
-Requires-Dist: redis[hiredis]<7.0.0,>=6.0.0
-
-# Pulumi Django Deployment
-
-This project aims to make a simple Django deployment on Azure easier.
-
-To have a proper and secure environment, we need these components:
-* Storage account for media and static files
-* CDN endpoint in front with a domain name of our choosing
-* PostgreSQL server
-* Azure Communication Services to send e-mails
-* Webapp with multiple custom host names and managed SSL for the website itself
-* Azure Key Vault per application
-* Webapp running pgAdmin
-
-## Project requirements
-
-## Installation
-This package is published on PyPi, so you can just add pulumi-django-azure to your requirements file.
-
-To use a specific branch in your project, add to pyproject.toml dependencies:
-```
-pulumi-django-azure = { git = "git@gitlab.com:MaartenUreel/pulumi-django-azure.git", branch = "dev" }
-```
-
-A simple project could look like this:
-```python
-import pulumi
-import pulumi_azure_native as azure
-from pulumi_django_azure import DjangoDeployment
-
-stack = pulumi.get_stack()
-config = pulumi.Config()
-
-
-# Create resource group
-rg = azure.resources.ResourceGroup(f"rg-{stack}")
-
-# Create VNet
-vnet = azure.network.VirtualNetwork(
-    f"vnet-{stack}",
-    resource_group_name=rg.name,
-    address_space=azure.network.AddressSpaceArgs(
-        address_prefixes=["10.0.0.0/16"],
-    ),
-)
-
-# Deploy the website and all its components
-django = DjangoDeployment(
-    stack,
-    tenant_id="abc123...",
-    resource_group_name=rg.name,
-    vnet=vnet,
-    pgsql_ip_prefix="10.0.10.0/24",
-    appservice_ip_prefix="10.0.20.0/24",
-    app_service_sku=azure.web.SkuDescriptionArgs(
-        name="B2",
-        tier="Basic",
-    ),
-    storage_account_name="mystorageaccount",
-    cdn_host="cdn.example.com",
-)
-
-django.add_django_website(
-    name="web",
-    db_name="mywebsite",
-    repository_url="git@gitlab.com:project/website.git",
-    repository_branch="main",
-    website_hosts=["example.com", "www.example.com"],
-    django_settings_module="mywebsite.settings.production",
-    comms_data_location="europe",
-    comms_domains=["mydomain.com"],
-)
-
-django.add_database_administrator(
-    object_id="a1b2c3....",
-    user_name="user@example.com",
-    tenant_id="a1b2c3....",
-)
-```
-
-## Changes to your Django project
-1. Add `pulumi_django_azure` to your `INSTALLED_APPS`
-2. Add to your settings file:
-   ```python
-   from pulumi_django_azure.settings import *  # noqa: F403
-
-   # This will provide the management command to purge the CDN and cache
-   INSTALLED_APPS += ["pulumi_django_azure"]
-
-   # This will provide the health check middleware that will also take care of credential rotation.
-   MIDDLEWARE += ["pulumi_django_azure.middleware.HealthCheckMiddleware"]
-   ```
-   This will pre-configure most settings to make your app work on Azure. You can check the source for details,
-   and ofcourse override any value after importing them.
-
-
-## Deployment steps
-1. Deploy without custom hosts (for CDN and websites)
-2. Configure the PostgreSQL server (create and grant permissions to role for your websites)
-3. Retrieve the deployment SSH key and configure your remote GIT repository with it
-4. Configure your CDN host (add the CNAME record)
-5. Configure your custom website domains (add CNAME/A record and TXT validation records)
-6. Re-deploy with custom hosts
-7. Re-deploy once more to enable HTTPS on website domains
-8. Manually activate HTTPS on the CDN host
-9. Go to the e-mail communications service on Azure and configure DKIM, SPF,... for your custom domains.
-
-## Custom domain name for CDN
-When deploying the first time, you will get a `cdn_cname` output. You need to create a CNAME to this domain before the deployment of the custom domain will succeed.
-
-You can safely deploy with the failing CustomDomain to get the CNAME, create the record and then deploy again.
-
-To enable HTTPS, you need to do this manually in the console. This is because of a limitation in the Azure API:
-https://github.com/Azure/azure-rest-api-specs/issues/17498
-
-## Custom domain names for web application
-Because of a circular dependency in custom domain name bindings and certificates that is out of our control, you need to deploy the stack twice.
-
-The first time will create the bindings without a certificate.
-The second deployment will then create the certificate for the domain (which is only possible if the binding exists), but also set the fingerprint of that certificate on the binding.
-
-To make the certificate work, you need to create a TXT record named `asuid` point to the output of `{your_app}_site_domain_verification_id`. For example:
-
-```
-asuid.mywebsite.com.      TXT  "A1B2C3D4E5..."
-asuid.www.mywebsite.com.  TXT  "A1B2C3D4E5..."
-```
-
-## Database authentication
-The PostgreSQL uses Entra ID authentication only, no passwords.
-
-### Administrator login
-If you want to log in to the database yourself, you can add yourself as an administrator with the `add_database_administrator` function.
-Your username is your e-mailaddress, a temporary password can be obtained using `az account get-access-token`.
-
-You can use this method to log in to pgAdmin.
-
-### Application
-Refer to this documentation:
-https://learn.microsoft.com/en-us/azure/postgresql/flexible-server/how-to-manage-azure-ad-users#create-a-role-using-microsoft-entra-object-identifier
-
-In short, run something like this in the `postgres` database:
-```
-SELECT * FROM pgaadauth_create_principal_with_oid('web_managed_identity', 'c8b25b85-d060-4cfc-bad4-b8581cfdf946', 'service', false, false);
-```
-Replace the GUID of course with the managed identity our web app gets.
-
-The name of the role is outputted by `{your_app}_site_db_user`
-
-Be sure to grant this role the correct permissions too.
-
-## pgAdmin specifics
-pgAdmin will be created with a default login:
-* Login: dbadmin@dbadmin.net
-* Password: dbadmin
-
-Best practice is to log in right away, create a user for yourself and delete this default user.
-
-## Azure OAuth2 / Django Social Auth
-If you want to set up login with Azure, which would make sense since you are in the ecosystem, you need to create an App Registration in Entra ID, create a secret and then register these settings in your stack:
-```
-pulumi config set --secret --path 'mywebsite_social_auth_azure.key' secret_ID
-pulumi config set --secret --path 'mywebsite_social_auth_azure.secret' secret_value
-pulumi config set --secret --path 'mywebsite_social_auth_azure.tenant_id' directory_tenant_id
-pulumi config set --secret --path 'mywebsite_social_auth_azure.client_id' application_id
-```
-
-Then in your Django deployment, pass to the `add_django_website` command:
-```
-secrets={
-    "mywebsite_social_auth_azure": "AZURE_OAUTH",
-},
-```
-
-The value will be automatically stored in the vault where the application has access to.
-The environment variable will be suffixed with `_SECRET_NAME`.
-
-Then, in your application, retrieve this data from the vault, e.g.:
-```python
-# Social Auth settings
-oauth_secret = AZURE_KEY_VAULT_CLIENT.get_secret(env("AZURE_OAUTH_SECRET_NAME"))
-oauth_secret = json.loads(oauth_secret.value)
-SOCIAL_AUTH_AZUREAD_TENANT_OAUTH2_KEY = oauth_secret["client_id"]
-SOCIAL_AUTH_AZUREAD_TENANT_OAUTH2_SECRET = oauth_secret["secret"]
-SOCIAL_AUTH_AZUREAD_TENANT_OAUTH2_TENANT_ID = oauth_secret["tenant_id"]
-SOCIAL_AUTH_ADMIN_USER_SEARCH_FIELDS = ["username", "first_name", "last_name", "email"]
-SOCIAL_AUTH_POSTGRES_JSONFIELD = True
-
-AUTHENTICATION_BACKENDS = (
-    "social_core.backends.azuread_tenant.AzureADTenantOAuth2",
-    "django.contrib.auth.backends.ModelBackend",
-)
-```
-
-And of course add the login button somewhere, following Django Social Auth instructions.
-
-## Automate deployments
-When using a service like GitLab, you can configure a Webhook to fire upon a push to your branch.
-
-You need to download the deployment profile to obtain the deployment username and password, and then you can construct a URL like this:
-
-```
-https://{user}:{pass}@{appname}.scm.azurewebsites.net/deploy
-
-```
-
-```
-https://{appname}.scm.azurewebsites.net/api/sshkey?ensurePublicKey=1
-```
-
-Be sure to configure the SSH key that Azure will use on GitLab side. You can obtain it using:
-
-This would then trigger a redeploy everytime you make a commit to your live branch.
-
-
-## Change requests
-I created this for internal use but since it took me a while to puzzle all the things together I decided to share it.
-Therefore this project is not super generic, but tailored to my needs. I am however open to pull or change requests to improve this project or to make it more usable for others.
+Metadata-Version: 2.3
+Name: pulumi-django-azure
+Version: 1.0.35
+Summary: Simply deployment of Django on Azure with Pulumi
+License: MIT
+Keywords: django,pulumi,azure
+Author: Maarten Ureel
+Author-email: maarten@youreal.eu
+Requires-Python: >=3.11,<3.14
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: azure-identity (>=1.24.0,<2.0.0)
+Requires-Dist: azure-keyvault-secrets (>=4.10.0,<5.0.0)
+Requires-Dist: azure-mgmt-cdn (>=13.1.1,<14.0.0)
+Requires-Dist: azure-mgmt-resource (>=24.0.0,<25.0.0)
+Requires-Dist: django (>=5.2.5,<6.0.0)
+Requires-Dist: django-azure-communication-email (>=1.3.2,<2.0.0)
+Requires-Dist: django-environ (>=0.12.0,<0.13.0)
+Requires-Dist: django-redis (>=6.0.0,<7.0.0)
+Requires-Dist: django-storages[azure] (>=1.14.6,<2.0.0)
+Requires-Dist: pulumi (>=3.189.0)
+Requires-Dist: pulumi-azure-native (>=3.7.1)
+Requires-Dist: pulumi-random (>=4.18.3)
+Requires-Dist: redis[hiredis] (>=6.4.0,<7.0.0)
+Requires-Dist: tenacity (>=9.1.2,<10.0.0)
+Project-URL: Homepage, https://gitlab.com/MaartenUreel/pulumi-django-azure
+Description-Content-Type: text/markdown
+
+# Pulumi Django Deployment
+
+This project aims to make a simple Django deployment on Azure easier.
+
+To have a proper and secure environment, we need these components:
+* Storage account for media and static files
+* CDN endpoint in front with a domain name of our choosing
+* PostgreSQL server
+* Azure Communication Services to send e-mails
+* Webapp with multiple custom host names and managed SSL for the website itself
+* Azure Key Vault per application
+* Webapp running pgAdmin
+
+## Project requirements
+
+## Installation
+This package is published on PyPi, so you can just add pulumi-django-azure to your requirements file.
+
+To use a specific branch in your project, add to pyproject.toml dependencies:
+```
+pulumi-django-azure = { git = "git@gitlab.com:MaartenUreel/pulumi-django-azure.git", branch = "dev" }
+```
+
+A simple project could look like this:
+```python
+import pulumi
+import pulumi_azure_native as azure
+from pulumi_django_azure import DjangoDeployment
+
+stack = pulumi.get_stack()
+config = pulumi.Config()
+
+
+# Create resource group
+rg = azure.resources.ResourceGroup(f"rg-{stack}")
+
+# Create VNet
+vnet = azure.network.VirtualNetwork(
+    f"vnet-{stack}",
+    resource_group_name=rg.name,
+    address_space=azure.network.AddressSpaceArgs(
+        address_prefixes=["10.0.0.0/16"],
+    ),
+)
+
+# Deploy the website and all its components
+django = DjangoDeployment(
+    stack,
+    tenant_id="abc123...",
+    resource_group_name=rg.name,
+    vnet=vnet,
+    pgsql_ip_prefix="10.0.10.0/24",
+    appservice_ip_prefix="10.0.20.0/24",
+    app_service_sku=azure.web.SkuDescriptionArgs(
+        name="B2",
+        tier="Basic",
+    ),
+    storage_account_name="mystorageaccount",
+    cdn_host="cdn.example.com",
+)
+
+django.add_django_website(
+    name="web",
+    db_name="mywebsite",
+    repository_url="git@gitlab.com:project/website.git",
+    repository_branch="main",
+    website_hosts=["example.com", "www.example.com"],
+    django_settings_module="mywebsite.settings.production",
+    comms_data_location="europe",
+    comms_domains=["mydomain.com"],
+)
+
+django.add_database_administrator(
+    object_id="a1b2c3....",
+    user_name="user@example.com",
+    tenant_id="a1b2c3....",
+)
+```
+
+## Changes to your Django project
+1. Add `pulumi_django_azure` to your `INSTALLED_APPS`
+2. Add to your settings file:
+   ```python
+   from pulumi_django_azure.settings import *  # noqa: F403
+
+   # This will provide the management command to purge the CDN and cache
+   INSTALLED_APPS += ["pulumi_django_azure"]
+
+   # This will provide the health check middleware that will also take care of credential rotation.
+   MIDDLEWARE += ["pulumi_django_azure.middleware.HealthCheckMiddleware"]
+   ```
+   This will pre-configure most settings to make your app work on Azure. You can check the source for details,
+   and ofcourse override any value after importing them.
+
+
+## Deployment steps
+1. Deploy without custom hosts (for CDN and websites)
+2. Configure the PostgreSQL server (create and grant permissions to role for your websites)
+3. Retrieve the deployment SSH key and configure your remote GIT repository with it
+4. Configure your CDN host (add the CNAME record)
+5. Configure your custom website domains (add CNAME/A record and TXT validation records)
+6. Re-deploy with custom hosts
+7. Re-deploy once more to enable HTTPS on website domains
+8. Manually activate HTTPS on the CDN host
+9. Go to the e-mail communications service on Azure and configure DKIM, SPF,... for your custom domains.
+
+## Custom domain name for CDN
+When deploying the first time, you will get a `cdn_cname` output. You need to create a CNAME to this domain before the deployment of the custom domain will succeed.
+
+You can safely deploy with the failing CustomDomain to get the CNAME, create the record and then deploy again.
+
+To enable HTTPS, you need to do this manually in the console. This is because of a limitation in the Azure API:
+https://github.com/Azure/azure-rest-api-specs/issues/17498
+
+## Custom domain names for web application
+Because of a circular dependency in custom domain name bindings and certificates that is out of our control, you need to deploy the stack twice.
+
+The first time will create the bindings without a certificate.
+The second deployment will then create the certificate for the domain (which is only possible if the binding exists), but also set the fingerprint of that certificate on the binding.
+
+To make the certificate work, you need to create a TXT record named `asuid` point to the output of `{your_app}_site_domain_verification_id`. For example:
+
+```
+asuid.mywebsite.com.      TXT  "A1B2C3D4E5..."
+asuid.www.mywebsite.com.  TXT  "A1B2C3D4E5..."
+```
+
+## Database authentication
+The PostgreSQL uses Entra ID authentication only, no passwords.
+
+### Administrator login
+If you want to log in to the database yourself, you can add yourself as an administrator with the `add_database_administrator` function.
+Your username is your e-mailaddress, a temporary password can be obtained using `az account get-access-token`.
+
+You can use this method to log in to pgAdmin.
+
+### Application
+Refer to this documentation:
+https://learn.microsoft.com/en-us/azure/postgresql/flexible-server/how-to-manage-azure-ad-users#create-a-role-using-microsoft-entra-object-identifier
+
+In short, run something like this in the `postgres` database:
+```
+SELECT * FROM pgaadauth_create_principal_with_oid('web_managed_identity', 'c8b25b85-d060-4cfc-bad4-b8581cfdf946', 'service', false, false);
+```
+Replace the GUID of course with the managed identity our web app gets.
+
+The name of the role is outputted by `{your_app}_site_db_user`
+
+Be sure to grant this role the correct permissions too.
+
+## pgAdmin specifics
+pgAdmin will be created with a default login:
+* Login: dbadmin@dbadmin.net
+* Password: dbadmin
+
+Best practice is to log in right away, create a user for yourself and delete this default user.
+
+## Azure OAuth2 / Django Social Auth
+If you want to set up login with Azure, which would make sense since you are in the ecosystem, you need to create an App Registration in Entra ID, create a secret and then register these settings in your stack:
+```
+pulumi config set --secret --path 'mywebsite_social_auth_azure.key' secret_ID
+pulumi config set --secret --path 'mywebsite_social_auth_azure.secret' secret_value
+pulumi config set --secret --path 'mywebsite_social_auth_azure.tenant_id' directory_tenant_id
+pulumi config set --secret --path 'mywebsite_social_auth_azure.client_id' application_id
+```
+
+Then in your Django deployment, pass to the `add_django_website` command:
+```
+secrets={
+    "mywebsite_social_auth_azure": "AZURE_OAUTH",
+},
+```
+
+The value will be automatically stored in the vault where the application has access to.
+The environment variable will be suffixed with `_SECRET_NAME`.
+
+Then, in your application, retrieve this data from the vault, e.g.:
+```python
+# Social Auth settings
+oauth_secret = AZURE_KEY_VAULT_CLIENT.get_secret(env("AZURE_OAUTH_SECRET_NAME"))
+oauth_secret = json.loads(oauth_secret.value)
+SOCIAL_AUTH_AZUREAD_TENANT_OAUTH2_KEY = oauth_secret["client_id"]
+SOCIAL_AUTH_AZUREAD_TENANT_OAUTH2_SECRET = oauth_secret["secret"]
+SOCIAL_AUTH_AZUREAD_TENANT_OAUTH2_TENANT_ID = oauth_secret["tenant_id"]
+SOCIAL_AUTH_ADMIN_USER_SEARCH_FIELDS = ["username", "first_name", "last_name", "email"]
+SOCIAL_AUTH_POSTGRES_JSONFIELD = True
+
+AUTHENTICATION_BACKENDS = (
+    "social_core.backends.azuread_tenant.AzureADTenantOAuth2",
+    "django.contrib.auth.backends.ModelBackend",
+)
+```
+
+And of course add the login button somewhere, following Django Social Auth instructions.
+
+## Automate deployments
+When using a service like GitLab, you can configure a Webhook to fire upon a push to your branch.
+
+You need to download the deployment profile to obtain the deployment username and password, and then you can construct a URL like this:
+
+```
+https://{user}:{pass}@{appname}.scm.azurewebsites.net/deploy
+
+```
+
+```
+https://{appname}.scm.azurewebsites.net/api/sshkey?ensurePublicKey=1
+```
+
+Be sure to configure the SSH key that Azure will use on GitLab side. You can obtain it using:
+
+This would then trigger a redeploy everytime you make a commit to your live branch.
+
+
+## Change requests
+I created this for internal use but since it took me a while to puzzle all the things together I decided to share it.
+Therefore this project is not super generic, but tailored to my needs. I am however open to pull or change requests to improve this project or to make it more usable for others.
+

pulumi_django_azure-1.0.35.dist-info/RECORD

@@ -0,0 +1,13 @@
+pulumi_django_azure/__init__.py,sha256=WoTHLNGnqc3dQoJtzrAJY8OVA7ReP6XFkDb9BXZGfJ8,117
+pulumi_django_azure/azure_helper.py,sha256=vZLIVZo44EP1-GGeq0XLJ10c42wJDDpKSL5-_sVgUzA,3053
+pulumi_django_azure/context_processors.py,sha256=Qm2e_WBipJYMDH3clYAAaHvEDkG8au2czSQqRkS5928,1136
+pulumi_django_azure/django_deployment.py,sha256=bVDEHrd7KeT6CAuLj0gozn_qSnfSBmm7iRk_6Yy2A34,46655
+pulumi_django_azure/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pulumi_django_azure/management/commands/purge_cache.py,sha256=yjMoNvEPFmtuZctOKXMUacfKJLlTC9xfF-0W-IH3kF0,488
+pulumi_django_azure/management/commands/purge_cdn.py,sha256=8iLuqjndvreTHXRp37sjpvcNltdGTpwhY9YiQokS_P0,2095
+pulumi_django_azure/management/commands/test_redis.py,sha256=_jQXmv48NSPVGrgGZTmASWm0WAWYhqt9HaE3XdJ22U4,10225
+pulumi_django_azure/middleware.py,sha256=XykZAmilyCaZR_5mM950h2WI4053HRqr95LGV1p8uR0,2472
+pulumi_django_azure/settings.py,sha256=hneKnLgm-gzxgX724wEs1rJxK6oq7W5EgT2sJyx7bxY,5231
+pulumi_django_azure-1.0.35.dist-info/METADATA,sha256=QmwtgaTBvlO8sL3AhD-DOGxFcu4iMzWyiOhVhTWuXgU,9598
+pulumi_django_azure-1.0.35.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+pulumi_django_azure-1.0.35.dist-info/RECORD,,

{pulumi_django_azure-1.0.34.dist-info → pulumi_django_azure-1.0.35.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.1.0)
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any
-

pulumi_django_azure-1.0.34.dist-info/RECORD

@@ -1,13 +0,0 @@
-pulumi_django_azure/__init__.py,sha256=WoTHLNGnqc3dQoJtzrAJY8OVA7ReP6XFkDb9BXZGfJ8,117
-pulumi_django_azure/azure_helper.py,sha256=7YCVlsygGUVBfvAsaHaqe_-A_6VVcvuryTgr1QMXqgs,2126
-pulumi_django_azure/context_processors.py,sha256=Qm2e_WBipJYMDH3clYAAaHvEDkG8au2czSQqRkS5928,1136
-pulumi_django_azure/django_deployment.py,sha256=l3hXP8Eo5ZUjojQtDsWeBGCFoSKN76NSz7tW9d-s9FA,50964
-pulumi_django_azure/middleware.py,sha256=7egut5QhBCleB-D3LHWMhZPh6bdrgWQqSShaXuV2tAM,3656
-pulumi_django_azure/settings.py,sha256=BTP5y6KE3oP9pY01TR1ML6GArpLhnzx-mFflrhTQ4SE,5906
-pulumi_django_azure/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pulumi_django_azure/management/commands/purge_cache.py,sha256=yjMoNvEPFmtuZctOKXMUacfKJLlTC9xfF-0W-IH3kF0,488
-pulumi_django_azure/management/commands/purge_cdn.py,sha256=8iLuqjndvreTHXRp37sjpvcNltdGTpwhY9YiQokS_P0,2095
-pulumi_django_azure-1.0.34.dist-info/METADATA,sha256=uNApn_QFC2kZWPEoQuVe3pPOARO42tfa0tgs3uIzGZM,9759
-pulumi_django_azure-1.0.34.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-pulumi_django_azure-1.0.34.dist-info/top_level.txt,sha256=MNPRJhq-_G8EMCHRkjdcb_xrqzOkmKogXUGV7Ysz3g0,20
-pulumi_django_azure-1.0.34.dist-info/RECORD,,

pulumi_django_azure-1.0.34.dist-info/top_level.txt

@@ -1 +0,0 @@
-pulumi_django_azure