Azure OpenAI 503 Service Unavailable — regional outage handling

# 1) Create an action group to receive alerts
az monitor action-group create \
  --name aoai-oncall \
  --resource-group my-rg \
  --short-name aoai-oc \
  --action email primary you@example.com \
  --action webhook pagerduty https://events.pagerduty.com/integration/xxx/enqueue

# 2) Create Service Health alert rule for Azure OpenAI in your regions
az monitor activity-log alert create \
  --name aoai-service-health \
  --resource-group my-rg \
  --scope /subscriptions/$SUB_ID \
  --condition category=ServiceHealth \
  --condition properties.impactedServices[*].ServiceName="Azure OpenAI" \
  --condition properties.impactedServices[*].ImpactedRegions[*].RegionName="East US" \
  --condition properties.impactedServices[*].ImpactedRegions[*].RegionName="West Europe" \
  --action-group aoai-oncall \
  --description "Alert on any Azure OpenAI incident in East US or West Europe"

# 3) Also create a health advisory alert (planned maintenance, retirements)
az monitor activity-log alert create \
  --name aoai-health-advisory \
  --resource-group my-rg \
  --scope /subscriptions/$SUB_ID \
  --condition category=ServiceHealth \
  --condition properties.incidentType=HealthAdvisory \
  --condition properties.impactedServices[*].ServiceName="Azure OpenAI" \
  --action-group aoai-oncall

import time
import random
from collections import deque
from openai import AzureOpenAI, APIError

class RegionalClient:
    def __init__(self, name: str, endpoint: str, api_key: str, deployment: str):
        self.name = name
        self.deployment = deployment
        self.client = AzureOpenAI(
            api_key=api_key,
            azure_endpoint=endpoint,
            api_version="2024-10-21",
        )
        self.window = deque(maxlen=100)  # (timestamp, was_error)
        self.sink_until = 0

    def score(self) -> float:
        """0.0 = broken, 1.0 = perfect."""
        if time.time() < self.sink_until:
            return 0.0
        if not self.window:
            return 1.0
        errors = sum(1 for _, e in self.window if e)
        return 1.0 - (errors / len(self.window))

    def record(self, was_error: bool):
        self.window.append((time.time(), was_error))
        # Sink for 30s after 5 errors in 100 requests
        if sum(1 for _, e in list(self.window)[-100:] if e) >= 5:
            self.sink_until = time.time() + 30

class MultiRegionClient:
    def __init__(self, regions: list[RegionalClient]):
        self.regions = regions

    def _pick(self) -> RegionalClient:
        """Choose the highest-scoring region, break ties randomly."""
        scores = [(r.score(), random.random(), r) for r in self.regions]
        scores.sort(reverse=True)
        return scores[0][2]

    def chat(self, messages: list, max_attempts: int = 3):
        errors = []
        for attempt in range(max_attempts):
            r = self._pick()
            try:
                resp = r.client.chat.completions.create(
                    model=r.deployment,
                    messages=messages,
                    max_tokens=500,
                    timeout=15.0,
                )
                r.record(False)
                return resp, r.name
            except APIError as e:
                r.record(True)
                errors.append((r.name, str(e)))
                if hasattr(e, "status_code") and e.status_code in {400, 401, 404}:
                    raise  # non-transient
        raise RuntimeError(f"All regions failed: {errors}")

# Setup
mc = MultiRegionClient([
    RegionalClient("eastus", "https://aoai-eastus.openai.azure.com",
                   "key1", "gpt4o-eastus"),
    RegionalClient("westeurope", "https://aoai-westeurope.openai.azure.com",
                   "key2", "gpt4o-westeurope"),
    RegionalClient("sweden", "https://aoai-sweden.openai.azure.com",
                   "key3", "gpt4o-sweden"),
])

resp, served_by = mc.chat([{"role": "user", "content": "hi"}])
print(f"Served by {served_by}")

import time
import random
from typing import Callable, TypeVar
from openai import APIError, RateLimitError, APITimeoutError

T = TypeVar("T")

def with_retry(
    fn: Callable[[], T],
    max_attempts: int = 3,
    base_delay: float = 1.0,
    max_delay: float = 30.0,
) -> T:
    """Call fn() with exponential backoff and full jitter on transient errors."""
    for attempt in range(1, max_attempts + 1):
        try:
            return fn()
        except (RateLimitError, APITimeoutError) as e:
            transient = True
            # Honor retry-after if provided
            retry_after = None
            if hasattr(e, "response") and e.response is not None:
                ra = e.response.headers.get("retry-after")
                retry_after = float(ra) if ra else None
        except APIError as e:
            transient = getattr(e, "status_code", 0) in {500, 502, 503, 504, 529}
            retry_after = None
            if not transient:
                raise  # non-transient — do not retry

        if attempt == max_attempts:
            raise

        # Exponential backoff with full jitter (better than "equal jitter")
        max_wait = min(max_delay, base_delay * (2 ** (attempt - 1)))
        wait = retry_after or random.uniform(0, max_wait)
        time.sleep(wait)

# Usage
from openai import AzureOpenAI
client = AzureOpenAI(api_key="...", azure_endpoint="...", api_version="2024-10-21")

def call():
    return client.chat.completions.create(
        model="gpt4o-prod",
        messages=[{"role": "user", "content": "..."}],
        max_tokens=200,
        timeout=15,
    )

response = with_retry(call, max_attempts=3, base_delay=1.0, max_delay=10.0)