Running AI workloads on Azure
Azure OpenAI deployments, AI Foundry and the surrounding compute — deployment types, quota, and the failure modes that only show up under load.
Azure does not sell you a model. It sells you a resource, and then a deployment inside that resource, and then a quota allocation attached to the deployment — three objects that are created separately, billed separately and fail separately. Most of the confusion people have with Azure OpenAI comes from treating those three as one thing, which is what the portal’s single create-and-deploy wizard quietly encourages. The first page in this cluster pulls them apart, and nearly every other page here depends on that separation being clear.
The rest works outward from the request. What the rate limiter counts and when it counts it, what a provisioned throughput unit actually buys per minute, how a content filter interposes itself between the model and your stream, what changes when the endpoint is only reachable inside a virtual network, and what a durable orchestrator gives you that a retry loop does not. Where a figure is Microsoft’s, it is dated and linked; where a figure moves, the page says which quota line or API to read for the current one rather than guessing on your behalf.
Deploying a Model on Azure OpenAI: Resource, Deployment and Quota
Create an Azure OpenAI resource and a model deployment inside it, and understand why the two are separate objects with separate bills.
10 min read
Requesting a Quota Increase on Azure OpenAI
How Azure OpenAI quota is allocated by tier, how to check what you actually have, and what the increase request form expects you to justify.
10 min read
Provisioned Throughput Units on Azure OpenAI, and Where They Break Even
What one PTU delivers per minute, how many you can buy, and the arithmetic that decides whether a commitment beats per-token billing.
11 min read
Configuring Content Filter Severity Levels on Azure OpenAI
Build a custom content filter configuration with per-category severity thresholds and attach it to a single deployment.
10 min read
Setting Up a Private Endpoint for Azure OpenAI
Put an Azure OpenAI resource behind a private endpoint, disable public network access, and prove that DNS resolves to the private address.
10 min read
Putting Azure API Management in Front of Azure OpenAI
Wire API Management in front of an Azure OpenAI resource as a policy layer for per-team token quota, key rotation and failover.
11 min read
Fixing a 429 Rate Limit on Azure OpenAI
Read the exact 429 you got, work out which of four different causes produced it, and fix that one.
11 min read
Streaming Responses From Azure OpenAI
Set stream: true against a deployment, handle the server-sent-events chunks it returns, and understand why the first chunks arrive in blocks.
10 min read
Azure OpenAI Regional Availability and Model Versions
Why a model version available in one Azure region is absent from another, and how deployment type changes the question.
9 min read
Authenticating to Azure OpenAI With Managed Identity
Replace the Azure OpenAI API key with a managed identity token, and assign the one role that actually permits inference.
10 min read
Setting Up an Azure AI Foundry Project
Create a Foundry project and understand which Azure resource owns the models, the connections and the secrets.
10 min read
Deploying a Model From the Azure AI Foundry Catalog
Deploy a catalog model as a serverless API deployment or onto managed compute, and call it with a real request.
10 min read
Building a Prompt Flow in Azure AI Foundry
Build a prompt flow with an LLM node and a Python tool node and deploy it as an endpoint — and know how long the feature has left.
10 min read
Connecting Azure AI Foundry to Your Own Data
Wire an Azure AI Search connection into a Foundry project and use it to ground a model's answers in your own documents.
10 min read
Durable Functions for a Multi-Step Model Workflow on Azure
Build an orchestrator function that chains model calls with checkpointed state, so a crash resumes rather than restarts.
11 min read
An HTTP-Triggered Azure Function That Calls a Model API
Build and deploy a minimal HTTP-triggered function that proxies a request to Azure OpenAI, with the two limits that bite before your code does.
9 min read
Choosing a Hosting Plan for an Azure Function That Calls a Model
When a scale-to-zero plan's cold start is acceptable for a model-calling function, and which limit actually forces you onto Premium.
10 min read
Fixing an Azure Function Timeout on a Slow Model Call
Why raising functionTimeout does not fix an HTTP-triggered function that dies at 230 seconds, and what does.
10 min read
Deploying a Model-Calling Service on Azure Container Apps
Create an environment, deploy a revision with ingress and secrets, and set the replica floor that keeps a model proxy warm.
11 min read
KEDA Scaling on Azure Container Apps for Queue-Driven Inference
Set a Service Bus scale rule, and understand why messageCount is a per-replica target rather than a queue threshold.
11 min read
Dapr Pub/Sub on Azure Container Apps for a Model Pipeline
Wire a Dapr pub/sub component so an ingest service and an inference service exchange events, and handle the redelivery that costs you money.
10 min read
GPU Workload Profiles on Azure Container Apps
Request serverless GPU quota, add a consumption GPU workload profile, and deploy a container that gets the device.
10 min read
Storing an API Key in Azure Key Vault for a Function App
Wire Key Vault references into function app settings so the provider key never sits in plain config, and recognise the failure that sends the reference string to your model provider.
11 min read
Setting a Cost Alert on Azure OpenAI Spend
Scope a Cost Management budget to the Azure OpenAI resource with actual and forecasted thresholds, and understand why it cannot stop a runaway loop.
10 min read
VNet Integration for Azure OpenAI and Container Apps
Put a Container Apps environment in your own subnet and lock the Azure OpenAI resource to it, using a service endpoint or a private endpoint.
11 min read
Role-Based Access Control for Azure OpenAI Resources
Assign Cognitive Services OpenAI User instead of Contributor, and understand the inversion that leaves the more powerful role unable to make inference calls.
10 min read
Azure OpenAI Pricing: Reading the Deployment Rates
The three axes that set an Azure OpenAI rate, the unit trap in the price list, and how to fetch today's number from the public prices API.
10 min read
Fixing "TooManyRequests" From Azure OpenAI Under Load
One status code, four documented root causes, and the response headers that tell you which one you have before you pick a remedy.
10 min read
How Azure OpenAI's Global Standard Deployment Type Works
What GlobalStandard actually routes, where the data is processed, why a second regional deployment may add no quota, and why none of it is failover.
10 min read
Setting Up Failover Between Two Azure OpenAI Deployments
Build application-level failover between two regional Azure OpenAI resources that triggers on 429 and 5xx, with the details that make the swap safe.
11 min read
Other topics
- LLM fundamentals & architecture
- Tokens, tokenization & context windows
- Prompt engineering
- Reasoning models & test-time compute
- Multimodal AI: vision, audio, video
- RAG & retrieval
- Embeddings & vector search
- AI agents & tool use
- Structured output & function calling
- Fine-tuning & post-training
- Local inference errors, string by string
- Running local models day to day
- Testing code that calls an LLM
- Snapshot and property testing for model output
- Regression suites for prompts
- Eval gates in CI
- Flaky tests against a model
- Determinism and the cost of testing
- Contract and streaming tests
- Testing tool calls and retrieval
- Inference, serving & latency
- Rolling out a prompt change
- Testing AI systems in practice
- Forecasting a time series
- Machine learning on tabular data
- Geospatial data and models
- Understanding audio that is not speech
- Understanding video
- Core computer vision tasks
- Machine learning on graphs
- Point clouds and 3D
- Evaluation, benchmarks & LLM-as-judge
- Sensor and IoT data
- Logs and event streams
- Models over biological sequences
- Machine learning on molecules
- Embedding and searching code
- Extracting invoices and purchase orders
- Receipts, statements and tax forms
- Insurance policies and contracts
- Deeds, court filings and patents
- Extracting from medical records
- Observability & LLMOps
- CVs, certificates and identity documents
- Shipping, customs and technical documents
- Meetings, email, chat and filled-in forms
- Building an extraction pipeline
- Business, property and inspection documents
- Contract clauses and insurance claims
- Regulated and compliance documents
- Consumer, travel and closing documents
- Mapping one chat API onto another
- SDK and framework migrations
- Hallucination & failure modes
- Re-embedding and model deprecation
- Cutting over between providers
- Parity gaps, shims and legacy endpoints
- Moving between model versions
- Migrating vector stores and caches
- Mapping capabilities and parameters
- Migrating pipelines and agents
- Contracts, runbooks and rollback
- Auditing a codebase before a cutover
- Compliance and fine-tune migration
- LLM cost engineering
- Routing, cost tracking and multi-tenancy
- What a migration does to your prompts
- AI security & prompt injection
- Privacy, compliance & data residency
- AI governance, policy & society
- Building reliable AI applications
- AI hardware, GPUs & compute
- Open-weight models & local inference
- AI for developers & coding agents
- AI in industry: vertical playbooks
- AGI, superintelligence, alignment & the long future
- Machine learning foundations
- NLP fundamentals & classical tasks
- Data engineering for AI
- Synthetic data & dataset curation
- AI product design & UX
- Search, ranking & recommendation
- Enterprise adoption & change management
- AI careers, skills & teams
- Reading AI research
- AI in science & discovery
- Robotics & embodied AI
- AI economics, markets & business models
- AI myths, hype & media literacy
- Context engineering
- Shipping AI features: patterns & anti-patterns
- Build it: end-to-end AI tutorials
- Python for AI: hands-on recipes
- TypeScript, React and the web
- Frameworks and SDKs
- Errors and troubleshooting
- AI facts, numbers and statistics
- The history of AI
- The maths behind AI
- Architectures beyond the transformer
- Reinforcement learning
- Diffusion and generative media
- Speech, audio and voice engineering
- Benchmarks, one at a time
- AI search visibility
- Infrastructure and operations
- Databases and storage for AI
- Knowledge graphs and structured knowledge
- Classical ML in production
- Regulation, jurisdiction by jurisdiction
- Prompt recipes and pattern library
- AI for people who do not write code
- Writing, media and creative work
- Edge and on-device AI
- Interpretability and model internals
- Field notes
- OpenAI model behaviour
- Claude model behaviour
- Gemini model behaviour
- Llama model behaviour
- Mistral model behaviour
- Qwen model behaviour
- DeepSeek model behaviour
- Cohere model behaviour
- Grok model behaviour
- Small model behaviour
- Hybrid model architectures
- Token cost by language and script
- Transliteration, romanization and script handling
- Locale-correct output
- Multilingual generation quality
- Multilingual pipelines
- The EU AI Act, article by article
- AI under the GDPR and EU data law
- US AI regulation, state and sector
- International AI governance and standards
- AI litigation and enforcement
- Running AI workloads on AWS
- Running AI workloads on Google Cloud
- AI at the edge: Workers, Vercel and Netlify
- Serving models on Kubernetes
- Operating AI infrastructure
- Quantization formats and what they cost
- llama.cpp, flag by flag
- Ollama and the desktop local-model runtimes
- Local models on Apple Silicon
- Hardware for local inference
- Running speech and embedding models locally
- Model files, adapters and conversion
- VRAM arithmetic for local models