pulumi-django-azure 1.0.21__py3-none-any.whl → 1.0.22__py3-none-any.whl

pulumi_django_azure/__init__.py

@@ -1 +1,2 @@
+from . import settings  # noqa: F401
 from .django_deployment import DjangoDeployment, HostDefinition  # noqa: F401

pulumi_django_azure/azure_helper.py

@@ -0,0 +1,67 @@
+import base64
+import json
+import os
+from dataclasses import dataclass
+from subprocess import check_output
+
+from azure.identity import DefaultAzureCredential
+from azure.mgmt.resource import SubscriptionClient
+from azure.mgmt.resource.subscriptions.models import Subscription
+
+# Azure credentials
+AZURE_CREDENTIAL = DefaultAzureCredential()
+
+# Get the local IP addresses of the machine (only when runnig on Azure)
+if os.environ.get("ORYX_ENV_NAME"):
+    LOCAL_IP_ADDRESSES = check_output(["hostname", "--all-ip-addresses"]).decode("utf-8").strip().split(" ")
+else:
+    LOCAL_IP_ADDRESSES = []
+
+
+def get_db_password() -> str:
+    """
+    Get a valid password for the database.
+    """
+    return AZURE_CREDENTIAL.get_token("https://ossrdbms-aad.database.windows.net/.default").token
+
+
+@dataclass
+class RedisCredentials:
+    username: str
+    password: str
+
+
+def get_redis_credentials() -> RedisCredentials:
+    """
+    Get valid credentials for the Redis cache.
+    """
+    token = AZURE_CREDENTIAL.get_token("https://redis.azure.com/.default").token
+    return RedisCredentials(_extract_username_from_token(token), token)
+
+
+def get_subscription() -> Subscription:
+    """
+    Get the subscription for the current user.
+    """
+    subscription_client = SubscriptionClient(AZURE_CREDENTIAL)
+    subscriptions = list(subscription_client.subscriptions.list())
+    return subscriptions[0]
+
+
+def _extract_username_from_token(token: str) -> str:
+    """
+    Extract the username from the JSON Web Token (JWT) token.
+    """
+    parts = token.split(".")
+    base64_str = parts[1]
+
+    if len(base64_str) % 4 == 2:
+        base64_str += "=="
+    elif len(base64_str) % 4 == 3:
+        base64_str += "="
+
+    json_bytes = base64.b64decode(base64_str)
+    json_str = json_bytes.decode("utf-8")
+    jwt = json.loads(json_str)
+
+    return jwt["oid"]

pulumi_django_azure/django_deployment.py

@@ -1,5 +1,4 @@
 from collections.abc import Sequence
-from typing import Optional, Union
 
 import pulumi
 import pulumi_azure_native as azure
@@ -15,7 +14,7 @@ class HostDefinition:
     :param identifier: An identifier for this host definition (optional).
     """
 
-    def __init__(self, host: str, zone: Optional[azure.network.Zone] = None, identifier: Optional[str] = None):
+    def __init__(self, host: str, zone: azure.network.Zone | None = None, identifier: str | None = None):
         self.host = host
         self.zone = zone
         self._identifier = identifier
@@ -68,12 +67,12 @@ class DjangoDeployment(pulumi.ComponentResource):
         app_service_ip_prefix: str,
         app_service_sku: azure.web.SkuDescriptionArgs,
         storage_account_name: str,
-        storage_allowed_origins: Optional[Sequence[str]] = None,
-        pgadmin_access_ip: Optional[Sequence[str]] = None,
-        pgadmin_dns_zone: Optional[azure.network.Zone] = None,
-        cache_ip_prefix: Optional[str] = None,
-        cache_sku: Optional[azure.cache.SkuArgs] = None,
-        cdn_host: Optional[HostDefinition] = None,
+        storage_allowed_origins: Sequence[str] | None = None,
+        pgadmin_access_ip: Sequence[str] | None = None,
+        pgadmin_dns_zone: azure.network.Zone | None = None,
+        cache_ip_prefix: str | None = None,
+        cache_sku: azure.cache.SkuArgs | None = None,
+        cdn_host: HostDefinition | None = None,
         opts=None,
     ):
         """
@@ -134,7 +133,7 @@ class DjangoDeployment(pulumi.ComponentResource):
         # Create a pgAdmin app
         self._create_pgadmin_app(access_ip=pgadmin_access_ip, dns_zone=pgadmin_dns_zone)
 
-    def _create_storage(self, account_name: str, allowed_origins: Optional[Sequence[str]] = None):
+    def _create_storage(self, account_name: str, allowed_origins: Sequence[str] | None = None):
         # Create blob storage
         self._storage_account = azure.storage.StorageAccount(
             f"sa-{self._name}",
@@ -169,7 +168,7 @@ class DjangoDeployment(pulumi.ComponentResource):
                 ),
             )
 
-    def _create_cdn(self, custom_host: Optional[HostDefinition]) -> pulumi.Output[str]:
+    def _create_cdn(self, custom_host: HostDefinition | None) -> pulumi.Output[str]:
         """
         Create a CDN endpoint. If a host name is given, it will be used as the custom domain.
         Otherwise, the default CDN host name will be returned.
@@ -392,7 +391,7 @@ class DjangoDeployment(pulumi.ComponentResource):
         self,
         name,
         prefix,
-        delegation_service: Optional[str] = None,
+        delegation_service: str | None = None,
         service_endpoints: Sequence[str] = [],
     ) -> azure.network.Subnet:
         """
@@ -433,7 +432,7 @@ class DjangoDeployment(pulumi.ComponentResource):
             sku=sku,
         )
 
-    def _create_pgadmin_app(self, access_ip: Optional[Sequence[str]] = None, dns_zone: Optional[azure.network.Zone] = None):
+    def _create_pgadmin_app(self, access_ip: Sequence[str] | None = None, dns_zone: azure.network.Zone | None = None):
         # Determine the IP restrictions
         ip_restrictions = []
         default_restriction = azure.web.DefaultAction.ALLOW
@@ -562,10 +561,10 @@ class DjangoDeployment(pulumi.ComponentResource):
     def _add_webapp_host(
         self,
         app: azure.web.WebApp,
-        host: Union[str, pulumi.Input[str]],
+        host: str | pulumi.Input[str],
         suffix: str,
         identifier: str,
-        depends_on: Optional[Sequence[pulumi.Resource]] = None,
+        depends_on: Sequence[pulumi.Resource] | None = None,
     ):
         """
         Because of a circular dependency, we need to create the certificate and the binding in two steps.
@@ -838,13 +837,13 @@ class DjangoDeployment(pulumi.ComponentResource):
         website_hosts: list[HostDefinition],
         django_settings_module: str,
         python_version: str = "3.13",
-        environment_variables: Optional[dict[str, str]] = None,
-        secrets: Optional[dict[str, str]] = None,
-        comms_data_location: Optional[str] = None,
-        comms_domains: Optional[list[HostDefinition]] = None,
-        dedicated_app_service_sku: Optional[azure.web.SkuDescriptionArgs] = None,
-        vault_administrators: Optional[list[str]] = None,
-        cache_db: Optional[int] = None,
+        environment_variables: dict[str, str] | None = None,
+        secrets: dict[str, str] | None = None,
+        comms_data_location: str | None = None,
+        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,
     ) -> azure.web.WebApp:
         """
         Create a Django website with it's own database and storage containers.

pulumi_django_azure/management/commands/purge_cdn.py

@@ -0,0 +1,52 @@
+import os
+
+from azure.mgmt.cdn import CdnManagementClient
+from azure.mgmt.cdn.models import PurgeParameters
+from django.conf import settings
+from django.core.management.base import BaseCommand
+from pulumi_django_azure.azure_helper import AZURE_CREDENTIAL
+
+
+class Command(BaseCommand):
+    help = "Purges the CDN endpoint"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--wait",
+            action="store_true",
+            help="Wait for the purge operation to complete",
+        )
+
+    def handle(self, *args, **options):
+        # Read environment variables
+        resource_group = os.getenv("WEBSITE_RESOURCE_GROUP")
+        profile_name = os.getenv("CDN_PROFILE")
+        endpoint_name = os.getenv("CDN_ENDPOINT")
+        content_paths = ["/*"]
+
+        # Ensure all required environment variables are set
+        if not all([resource_group, profile_name, endpoint_name]):
+            self.stderr.write(self.style.ERROR("Missing required environment variables."))
+            return
+
+        # Authenticate with Azure
+        cdn_client = CdnManagementClient(AZURE_CREDENTIAL, settings.AZURE_SUBSCRIPTION_ID)
+
+        try:
+            # Purge the CDN endpoint
+            purge_operation = cdn_client.endpoints.begin_purge_content(
+                resource_group_name=resource_group,
+                profile_name=profile_name,
+                endpoint_name=endpoint_name,
+                content_file_paths=PurgeParameters(content_paths=content_paths),
+            )
+
+            # Check if the --wait argument was provided
+            if options["wait"]:
+                purge_operation.result()  # Wait for the operation to complete
+                self.stdout.write(self.style.SUCCESS("CDN endpoint purge operation completed successfully."))
+            else:
+                self.stdout.write(self.style.SUCCESS("CDN endpoint purge operation started successfully."))
+
+        except Exception as e:
+            self.stderr.write(self.style.ERROR(f"Error executing CDN endpoint purge command: {e}"))

pulumi_django_azure/middleware.py

@@ -0,0 +1,43 @@
+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
+
+
+class HealthCheckMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        if request.path == settings.HEALTH_CHECK_PATH:
+            # Update the database credentials if needed
+            if settings.AZURE_DB_PASSWORD:
+                settings.DATABASES["default"]["PASSWORD"] = get_db_password()
+
+            # Update the Redis credentials if needed
+            if settings.AZURE_REDIS_CREDENTIALS:
+                redis_credentials = get_redis_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
+
+            try:
+                # Test the database connection
+                connection.ensure_connection()
+
+                # Test the Redis connection
+                cache.set("health_check", "test")
+
+                return HttpResponse("OK")
+
+            except OperationalError:
+                return HttpResponse(status=503)
+
+        return self.get_response(request)

pulumi_django_azure/settings.py

@@ -0,0 +1,137 @@
+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
+
+env = environ.Env()
+
+SECRET_KEY = env("DJANGO_SECRET_KEY")
+
+# Health check path
+HEALTH_CHECK_PATH = env("HEALTH_CHECK_PATH", default="/health")
+
+ALLOWED_HOSTS: list = env.list("DJANGO_ALLOWED_HOSTS", default=[])
+# WEBSITE_HOSTNAME contains the Azure domain name
+ALLOWED_HOSTS.append(env("WEBSITE_HOSTNAME"))
+# Add the local IP addresses of the machine for health checks
+ALLOWED_HOSTS.extend(LOCAL_IP_ADDRESSES)
+
+# Detect HTTPS behind AppService
+SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")
+
+
+# Azure context
+AZURE_SUBSCRIPTION = get_subscription()
+AZURE_TENANT_ID = AZURE_SUBSCRIPTION.tenant_id
+AZURE_SUBSCRIPTION_ID = AZURE_SUBSCRIPTION.subscription_id
+
+# Azure Key Vault
+AZURE_KEY_VAULT = env("AZURE_KEY_VAULT")
+AZURE_KEY_VAULT_URI = f"https://{AZURE_KEY_VAULT}.vault.azure.net"
+AZURE_KEY_VAULT_CLIENT = SecretClient(vault_url=AZURE_KEY_VAULT_URI, credential=AZURE_CREDENTIAL)
+
+# Allow CSRF cookies to be sent from our domains
+# CSRF_TRUSTED_ORIGINS = ["https://" + host for host in ALLOWED_HOSTS]
+AZURE_ACCOUNT_NAME = env("AZURE_STORAGE_ACCOUNT_NAME")
+AZURE_TOKEN_CREDENTIAL = AZURE_CREDENTIAL
+
+
+# CDN domain - shared for all storages
+AZURE_CUSTOM_DOMAIN = env("CDN_HOST")
+
+STORAGES = {
+    "default": {
+        "BACKEND": "storages.backends.azure_storage.AzureStorage",
+        "OPTIONS": {
+            "azure_container": env("AZURE_STORAGE_CONTAINER_MEDIA"),
+            "overwrite_files": False,
+        },
+    },
+    "staticfiles": {
+        "BACKEND": "storages.backends.azure_storage.AzureStorage",
+        "OPTIONS": {
+            "azure_container": env("AZURE_STORAGE_CONTAINER_STATICFILES"),
+        },
+    },
+}
+
+
+# STATIC_ROOT = BASE_DIR / "staticfiles"
+STATIC_URL = f"https://{AZURE_CUSTOM_DOMAIN}/static/"
+MEDIA_URL = f"https://{AZURE_CUSTOM_DOMAIN}/media/"
+
+# This setting enables password rotation in the health check middleware
+AZURE_DB_PASSWORD = True
+DATABASES = {
+    "default": {
+        "ENGINE": "django.db.backends.postgresql",
+        "NAME": env("DB_NAME"),
+        "USER": env("DB_USER"),
+        "HOST": env("DB_HOST"),
+        "PASSWORD": get_db_password(),
+        "PORT": "5432",
+        "OPTIONS": {
+            "sslmode": "require",
+        },
+        # Make connections persistent
+        "CONN_MAX_AGE": None,
+        # To enable health checks, add the following:
+        # "CONN_HEALTH_CHECKS": True,
+    }
+}
+
+# Email
+EMAIL_BACKEND = "django_azure_communication_email.EmailBackend"
+AZURE_COMMUNICATION_ENDPOINT = env("AZURE_COMMUNICATION_SERVICE_ENDPOINT")
+DEFAULT_FROM_EMAIL = env("DJANGO_DEFAULT_FROM_EMAIL")
+
+
+# Logging
+LOGGING = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "handlers": {
+        "file": {
+            "level": "INFO",
+            "class": "logging.handlers.RotatingFileHandler",
+            "filename": "/home/LogFiles/django.log",
+            "maxBytes": 1024 * 1024 * 100,  # 100 mb
+            "backupCount": 5,
+        },
+    },
+    "loggers": {
+        "django": {
+            "handlers": ["file"],
+            "level": "INFO",
+            "propagate": True,
+        },
+    },
+}
+
+# Redis, if enabled
+if env("REDIS_CACHE_HOST") and env("REDIS_CACHE_PORT") and env("REDIS_CACHE_DB"):
+    # This will enable the health check to update the Redis credentials
+    AZURE_REDIS_CREDENTIALS = True
+
+    # 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 = env("REDIS_CACHE_HOST")
+    REDIS_CACHE_PORT = env("REDIS_CACHE_PORT")
+    REDIS_CACHE_DB = env("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}",
+            "OPTIONS": {
+                "CLIENT_CLASS": "django_redis.client.DefaultClient",
+                "PARSER_CLASS": "redis.connection._HiredisParser",
+                "PASSWORD": REDIS_PASSWORD,
+            },
+        },
+    }

{pulumi_django_azure-1.0.21.dist-info → pulumi_django_azure-1.0.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pulumi-django-azure
-Version: 1.0.21
+Version: 1.0.22
 Summary: Simply deployment of Django on Azure with Pulumi
 Author-email: Maarten Ureel <maarten@youreal.eu>
 License: MIT License
@@ -30,12 +30,22 @@ Keywords: django,pulumi,azure
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.9
+Requires-Python: <3.14,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pulumi>=3.146.0
-Requires-Dist: pulumi-azure-native>=2.82.0
-Requires-Dist: pulumi-random>=4.17.0
+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.0,>=5.1.7
+Requires-Dist: django-azure-communication-email<2.0.0,>=1.3.0
+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.5
+Requires-Dist: pulumi>=3.156.0
+Requires-Dist: pulumi-azure-native>=2.89.1
+Requires-Dist: pulumi-random>=4.18.0
+Requires-Dist: redis[hiredis]<6.0.0,>=5.2.1
 
 # Pulumi Django Deployment
 
@@ -57,12 +67,36 @@ Your Django project should contain a folder `cicd` with these files:
   Note that this runs in the identity of the build container, so you should not run database or storage manipulations here.
 * startup.sh: commands to run the actual application. I recommend to put at least:
   ```bash
+  # Compile translations
+  apt-get -y install gettext
+  python manage.py compilemessages
+
+  # Run collectstatic in the background
+  sh cicd/collectstatic.sh &
+
   python manage.py migrate
-  python manage.py collectstatic --noinput
-  python manage.py purge_cdn
   gunicorn --timeout 600 --workers $((($NUM_CORES*2)+1)) --chdir $APP_PATH yourapplication.wsgi --access-logfile '-' --error-logfile '-'
   ```
-  Be sure to change `yourapplication` in the above. To see the `purge_cdn` management command we use here, see below.
+
+  Be sure to change `yourapplication` in the above.
+
+* collecstatic.sh
+  ```bash
+  #!/bin/bash
+
+  LOGFILE="/var/log/django_collectstatic.log"
+
+  # Collectstatic
+  echo "$(date '+%Y-%m-%d %H:%M:%S') - Starting collectstatic" >> $LOGFILE
+  python manage.py collectstatic --noinput -v 2 >> $LOGFILE
+  echo "$(date '+%Y-%m-%d %H:%M:%S') - Finished collectstatic" >> $LOGFILE
+
+  # Purge the CDN
+  echo "$(date '+%Y-%m-%d %H:%M:%S') - Starting purge_cdn" >> $LOGFILE
+  python manage.py purge_cdn >> $LOGFILE
+  echo "$(date '+%Y-%m-%d %H:%M:%S') - Finished purge_cdn" >> $LOGFILE
+  ```
+
 ## Installation
 This package is published on PyPi, so you can just add pulumi-django-azure to your requirements file.
 
@@ -127,8 +161,23 @@ django.add_database_administrator(
 )
 ```
 
-## Deployment steps
+## 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
+   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
@@ -211,19 +260,8 @@ The environment variable will be suffixed with `_SECRET_NAME`.
 
 Then, in your application, retrieve this data from the vault, e.g.:
 ```python
-from azure.keyvault.secrets import SecretClient
-from azure.identity import DefaultAzureCredential
-
-# Azure credentials
-azure_credential = DefaultAzureCredential()
-
-# Azure Key Vault
-AZURE_KEY_VAULT = env("AZURE_KEY_VAULT")
-AZURE_KEY_VAULT_URI = f"https://{AZURE_KEY_VAULT}.vault.azure.net"
-azure_key_vault_client = SecretClient(vault_url=AZURE_KEY_VAULT_URI, credential=azure_credential)
-
 # Social Auth settings
-oauth_secret = azure_key_vault_client.get_secret(env("AZURE_OAUTH_SECRET_NAME"))
+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"]
@@ -257,81 +295,6 @@ Be sure to configure the SSH key that Azure will use on GitLab side. You can obt
 
 This would then trigger a redeploy everytime you make a commit to your live branch.
 
-## CDN Purging
-We added a management command to Django to purge the CDN cache, and added that to the startup script. Our version is here:
-```python
-import os
-
-from azure.mgmt.cdn import CdnManagementClient
-from azure.mgmt.cdn.models import PurgeParameters
-from django.core.management.base import BaseCommand
-
-from core.azure_helper import AZURE_CREDENTIAL, get_subscription_id
-
-
-class Command(BaseCommand):
-    help = "Purges the CDN endpoint"
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            "--wait",
-            action="store_true",
-            help="Wait for the purge operation to complete",
-        )
-
-    def handle(self, *args, **options):
-        # Read environment variables
-        resource_group = os.getenv("WEBSITE_RESOURCE_GROUP")
-        profile_name = os.getenv("CDN_PROFILE")
-        endpoint_name = os.getenv("CDN_ENDPOINT")
-        content_paths = ["/*"]
-
-        # Ensure all required environment variables are set
-        if not all([resource_group, profile_name, endpoint_name]):
-            self.stderr.write(self.style.ERROR("Missing required environment variables."))
-            return
-
-        # Authenticate with Azure
-        cdn_client = CdnManagementClient(AZURE_CREDENTIAL, get_subscription_id())
-
-        try:
-            # Purge the CDN endpoint
-            purge_operation = cdn_client.endpoints.begin_purge_content(
-                resource_group_name=resource_group,
-                profile_name=profile_name,
-                endpoint_name=endpoint_name,
-                content_file_paths=PurgeParameters(content_paths=content_paths),
-            )
-
-            # Check if the --wait argument was provided
-            if options["wait"]:
-                purge_operation.result()  # Wait for the operation to complete
-                self.stdout.write(self.style.SUCCESS("CDN endpoint purge operation completed successfully."))
-            else:
-                self.stdout.write(self.style.SUCCESS("CDN endpoint purge operation started successfully."))
-
-        except Exception as e:
-            self.stderr.write(self.style.ERROR(f"Error executing CDN endpoint purge command: {e}"))
-```
-
-And our azure_helper:
-```python
-from azure.identity import DefaultAzureCredential
-from azure.mgmt.resource import SubscriptionClient
-
-# Azure credentials
-AZURE_CREDENTIAL = DefaultAzureCredential()
-
-
-def get_db_password() -> str:
-    return AZURE_CREDENTIAL.get_token("https://ossrdbms-aad.database.windows.net/.default").token
-
-
-def get_subscription_id() -> str:
-    subscription_client = SubscriptionClient(AZURE_CREDENTIAL)
-    subscriptions = list(subscription_client.subscriptions.list())
-    return subscriptions[0].subscription_id
-```
 
 ## 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.

pulumi_django_azure-1.0.22.dist-info/RECORD

@@ -0,0 +1,12 @@
+pulumi_django_azure/__init__.py,sha256=WoTHLNGnqc3dQoJtzrAJY8OVA7ReP6XFkDb9BXZGfJ8,117
+pulumi_django_azure/azure_helper.py,sha256=HU0cb85jTeh70qjv11foWuqgE-SNQ21bhMKsy1lB7MM,1903
+pulumi_django_azure/django_deployment.py,sha256=bSMczOl7nivLGVhfEXroDc_FyD0hXLne1TwhdhLMoNY,49260
+pulumi_django_azure/middleware.py,sha256=AtZJO3NJLaf6Zdkbv2_SV9UeCZpXShMfomxpMEE0ab0,1546
+pulumi_django_azure/settings.py,sha256=2Mu1k5bvx8LIgbGH8qI2RcKixyZW2njeHGUda39P4Xs,4496
+pulumi_django_azure/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pulumi_django_azure/management/commands/purge_cdn.py,sha256=1lZI5liDIiOGyJRmo9gRn-BDLHaRuipaUmUAm06bRr0,2093
+pulumi_django_azure-1.0.22.dist-info/LICENSE,sha256=NX2LN3U319Zaac8b7ZgfNOco_nTBbN531X_M_13niSg,1087
+pulumi_django_azure-1.0.22.dist-info/METADATA,sha256=uND6SLUYtIOnTqHsh7rf_p7QVVTQQqy-6y4pKLYXl2k,12514
+pulumi_django_azure-1.0.22.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+pulumi_django_azure-1.0.22.dist-info/top_level.txt,sha256=MNPRJhq-_G8EMCHRkjdcb_xrqzOkmKogXUGV7Ysz3g0,20
+pulumi_django_azure-1.0.22.dist-info/RECORD,,

pulumi_django_azure-1.0.21.dist-info/RECORD

@@ -1,7 +0,0 @@
-pulumi_django_azure/__init__.py,sha256=5RY9reSVNw-HULrOXfhcq3cyPne-94ojFmeV1m6kIVg,79
-pulumi_django_azure/django_deployment.py,sha256=e4DHIoB3ibzFHAuK1lwaRCLrLly5DdhikQLuhOMYpBc,49365
-pulumi_django_azure-1.0.21.dist-info/LICENSE,sha256=NX2LN3U319Zaac8b7ZgfNOco_nTBbN531X_M_13niSg,1087
-pulumi_django_azure-1.0.21.dist-info/METADATA,sha256=QiN9s5lzA-moy_wwLxZSScUqj-p1goLfUIHmBrG7eQA,13955
-pulumi_django_azure-1.0.21.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-pulumi_django_azure-1.0.21.dist-info/top_level.txt,sha256=MNPRJhq-_G8EMCHRkjdcb_xrqzOkmKogXUGV7Ysz3g0,20
-pulumi_django_azure-1.0.21.dist-info/RECORD,,