Architecture

Integration architecture patterns

The patterns that keep showing up in modern Azure integration work — each grounded in official guidance from the Azure Architecture Center cloud design patterns catalog and its reference architectures, with the services involved and a reference diagram. New guidance from the Architecture Center feeds the changelog weekly and gets folded in here. Deployable reference implementations live in the official accelerators below.

1 · AI Gateway (GenAI front door)

Services: APIM · Azure OpenAI / AI Foundry · App Insights. Problem: uncontrolled model access, invisible token spend, 429 cascades, agents holding raw keys.

flowchart LR
    APPS[Apps · copilots · agents] --> APIM[APIM AI Gateway
token limits · metrics ·
semantic cache · content safety]
    APIM -->|priority 1| PTU[Azure OpenAI PTU]
    APIM -->|spillover| PAYG[Azure OpenAI PAYG]
    APIM --> OSS[Foundry open models
on Container Apps GPU]
    APIM --> AI[App Insights
tokens per team]
One governed endpoint for every model; cost attribution and failover are platform concerns, not app concerns.

Full detail on the APIM page. Official guidance: GenAI gateway reference architecture · AI-Gateway labs

2 · Governed agent tools (MCP hub)

Services: APIM · AI Foundry Agent Service · Functions · Logic Apps. Problem: agents need real enterprise actions without scattering credentials.

flowchart LR
    AG[Foundry agents ·
GitHub Copilot · MCP clients] --> APIM[APIM
MCP server façade
Entra auth · rate limits · tracing]
    APIM --> API1[Existing REST APIs]
    APIM --> FN[Functions MCP tools]
    APIM --> LA[Logic Apps workflows
as tools]
Existing APIs become agent tools through the gateway — governance follows the tool, not the agent.

Official guidance: Expose APIs as MCP servers · Gateway Offloading pattern

3 · API-led connectivity

Services: APIM (workspaces/products) · everything behind it. Problem: point-to-point spaghetti between systems, teams blocked on each other.

flowchart TB
    subgraph XP[Experience APIs]
        X1[Mobile BFF]
        X2[Partner API]
    end
    subgraph PR[Process APIs]
        P1[Order process]
        P2[Customer 360]
    end
    subgraph SYS[System APIs]
        S1[SAP façade]
        S2[CRM façade]
        S3[Warehouse façade]
    end
    X1 --> P1
    X2 --> P1
    X1 --> P2
    P1 --> S1
    P1 --> S3
    P2 --> S2
Three reusable layers, each an APIM product with its own contract, owners and policies; teams federate via workspaces.

Official guidance: API design best practices · APIM landing zone accelerator

4 · Event-driven architecture

Services: Event Grid · Service Bus · Functions · Container Apps. Problem: tight coupling and synchronous chains that fail together.

flowchart LR
    SRC[Producers
apps · Azure services · MQTT] --> EG[Event Grid
route + filter]
    EG -->|critical commands| SB[(Service Bus
guaranteed delivery)]
    EG -->|reactive| FN[Functions]
    SB --> W[Container Apps workers
KEDA scale on depth]
    FN --> DS[(Downstream systems)]
    W --> DS
Grid routes facts; the bus guarantees work; compute scales with the backlog. Producers know nothing about consumers.

Official guidance: Event-driven architecture style · Publisher-Subscriber pattern

5 · Async request-reply

Services: APIM · Functions/Durable · Service Bus. Problem: operations that outlive an HTTP timeout.

sequenceDiagram
    participant C as Client
    participant G as APIM
    participant F as Function (starter)
    participant O as Orchestration / queue worker
    C->>G: POST /reports
    G->>F: forward
    F->>O: enqueue / start orchestration
    F-->>C: 202 Accepted + Location: /reports/status/123
    loop until done
        C->>G: GET /reports/status/123
        G-->>C: 200 running (Retry-After)
    end
    C->>G: GET /reports/status/123
    G-->>C: 302 → result URI
202 + status endpoint: the canonical way to put long-running work behind a synchronous API.

Official guidance: Asynchronous Request-Reply pattern

6 · Saga (distributed transactions)

Services: Durable Functions or Logic Apps · Service Bus. Problem: multi-service transactions with no 2PC.

flowchart LR
    O[Orchestrator
Durable Function / Logic App] --> A[Reserve inventory]
    A --> B[Charge payment]
    B --> C[Create shipment]
    C -->|fail| CC[Compensate: refund payment]
    CC --> CA[Compensate: release inventory]
Every step has a compensator; the orchestrator guarantees either full completion or full compensation.

Official guidance: Saga design pattern · Compensating Transaction pattern

7 · Strangler fig modernization

Services: APIM · Functions/Container Apps · legacy system. Problem: replacing a monolith without a big-bang cutover.

flowchart LR
    C[Clients] --> G[APIM façade
stable contract]
    G -->|/orders migrated| N[New microservice
Container Apps]
    G -->|/invoices not yet| L[Legacy monolith / SOAP]
    N -.eventually all routes.-> G
The gateway owns the contract; routes flip from legacy to new one at a time, invisibly to clients.

Official guidance: Strangler Fig pattern · Anti-Corruption Layer pattern

8 · Claim check & load leveling

Services: Service Bus · Blob Storage · Functions. Problem: large payloads and bursty traffic overwhelming consumers.

flowchart LR
    P[Producer] -->|1. upload payload| BLOB[(Blob Storage)]
    P -->|2. send reference| Q[(Service Bus queue)]
    Q -->|steady drain| W[Workers]
    W -->|3. fetch payload| BLOB
The bus carries claim tickets, not payloads; the queue absorbs bursts so workers process at a sustainable rate.

Official guidance: Claim-Check pattern · Queue-Based Load Leveling pattern

9 · Serverless RAG pipeline

Services: Blob Storage · Event Grid · Functions · AI Search · APIM · Azure OpenAI / AI Foundry. Problem: grounding LLM answers in enterprise documents that change daily.

flowchart LR
    DOC[Documents land in
Blob Storage] --> EG[Event Grid
BlobCreated]
    EG --> ING[Functions
chunk · embed · enrich]
    ING --> IDX[(AI Search index
vectors + keywords)]
    U[App / copilot] --> APIM[APIM AI Gateway]
    APIM --> ORCH[Orchestrator
Container Apps / Functions]
    ORCH -->|retrieve| IDX
    ORCH -->|grounded prompt| AOAI[Azure OpenAI
via APIM pool]
    AOAI --> ORCH --> U
Event-driven ingestion keeps the index fresh with zero polling; every model call still flows through the AI Gateway for token governance.

Official guidance: Baseline OpenAI end-to-end chat architecture · RAG solution design guide

10 · Multi-agent enterprise automation

Services: AI Foundry Agent Service · Logic Apps agent workflows · APIM (MCP) · Container Apps dynamic sessions · Service Bus. Problem: automating a business process end-to-end where multiple specialized agents must plan, act on enterprise systems, and run code — safely.

flowchart TB
    REQ[Business request
e.g. month-end reconciliation] --> ORCH[Foundry orchestrator agent]
    ORCH -->|delegate| A1[Data agent]
    ORCH -->|delegate| A2[Process agent
Logic Apps agent loop]
    ORCH -->|delegate| A3[Analysis agent]
    A1 -->|MCP tools| APIM[APIM
governed tool hub]
    APIM --> ERP[ERP / CRM / finance APIs]
    A2 -->|connectors as tools| SAAS[SAP · Dynamics · Teams]
    A3 -->|generated code| DS[Container Apps
dynamic sessions sandbox]
    ORCH -->|audit events| SB[(Service Bus
audit + human escalation queue)]
    SB --> HUM[Human review
when confidence is low]
Specialized agents divide the work; APIM keeps every tool call governed; risky code runs in isolated sandboxes; Service Bus provides the audit trail and human-in-the-loop escape hatch.

Official guidance: AI agent orchestration patterns · AI-Gateway labs (MCP + agents)

11 · Hybrid integration platform

Services: APIM self-hosted gateway · Logic Apps Standard (hybrid) · Service Bus · Azure Arc. Problem: factories, hospitals or sovereign environments where data must stay local but governance must stay central.

flowchart LR
    subgraph Cloud[Azure · control plane]
        MP[APIM management plane]
        MON[Azure Monitor
central observability]
        SB[(Service Bus
cloud ↔ site bridge)]
    end
    subgraph Site[On-prem site · Arc-enabled K8s]
        SH[Self-hosted APIM gateway]
        LAH[Logic Apps hybrid
local workflows]
        LOB[(Local systems
MES · ERP · devices)]
    end
    APPS[Site apps] --> SH --> LOB
    LAH --> LOB
    LAH <-->|reliable async| SB
    SH -.config & telemetry.-> MP
    LAH -.logs.-> MON
Traffic and data stay on-site; policy, config and observability stay central; Service Bus bridges cloud and edge asynchronously so outages don't lose work.

Official guidance: Self-hosted gateway overview · Integration Services landing zone accelerator

12 · Real-time IoT telemetry & alerting

Services: Event Grid (MQTT) · Event Hubs · Stream Analytics / Fabric · Functions · Service Bus. Problem: millions of device signals needing both real-time reaction and historical analytics.

flowchart LR
    DEV[Device fleet
MQTT] --> EG[Event Grid
MQTT broker + routing]
    EG -->|bulk telemetry| EH[(Event Hubs
partitioned stream)]
    EG -->|critical alerts| SB[(Service Bus
guaranteed delivery)]
    EH --> SA[Stream Analytics /
Fabric eventstream]
    EH -->|Capture| DL[(Data lake
history + ML training)]
    SA --> RT[Real-time dashboards]
    SB --> FN[Functions
alert handler]
    FN --> OPS[On-call · Teams · ticket]
One ingestion fabric, two lanes: the firehose streams to analytics while critical events take the guaranteed-delivery lane to action.

Official guidance: Event Grid MQTT broker · Stream processing architectures

13 · Global multi-region API platform

Services: Front Door · APIM (multi-region) · Container Apps / App Service · Cosmos DB. Problem: serving a global audience with low latency and surviving a regional outage.

flowchart TB
    U[Global users] --> FD[Azure Front Door
WAF · TLS · anycast routing]
    FD --> G1[APIM gateway
West Europe]
    FD --> G2[APIM gateway
East US]
    G1 --> B1[Container Apps / App Service
West Europe]
    G2 --> B2[Container Apps / App Service
East US]
    B1 <--> DB[(Cosmos DB
multi-region writes)]
    B2 <--> DB
    G1 -.one management plane.- G2
Front Door steers users to the nearest healthy region; APIM Premium replicates gateways under one control plane; Cosmos DB keeps state consistent across regions.

Official guidance: Multi-region web app reference architecture · Geode pattern

Official accelerators & reference implementations

Microsoft-maintained GitHub repos with deployable IaC (Bicep/Terraform), reference implementations and labs for these patterns. Their releases are tracked automatically in the changelog.

Azure/apim-landing-zone-accelerator

APIM landing zone accelerator

Enterprise-grade APIM deployment: network topology, private endpoints, APIOps CI/CD, and GenAI gateway scenarios aligned with the landing zone design areas.
Azure/Integration-Services-Landing-Zone-Accelerator

Integration Services landing zone

Reference implementation for AIS at enterprise scale — Logic Apps, Service Bus, APIM and storage wired together with identity, networking and monitoring done right.
Azure-Samples/AI-Gateway

AI-Gateway labs

Hands-on labs for every APIM GenAI policy: token limiting/metering, semantic caching, load balancing, MCP servers, agent integration — the fastest way to try the AI Gateway pattern.
Azure-Samples/ai-hub-gateway-solution-accelerator

AI Hub Gateway accelerator

Production-grade central AI API gateway: multi-tenant OpenAI access, usage tracking and chargeback dashboards, deployable end to end.
Azure/aca-landing-zone-accelerator

Container Apps landing zone

Secure-baseline internal environment for Container Apps: hub-spoke networking, private ingress, Dapr, and zone redundancy as IaC.
Azure/appservice-landing-zone-accelerator

App Service landing zone

Reference implementations for secure App Service deployments — multi-tenant and ASE variants with networking, WAF and deployment slots.
Azure/AI-Landing-Zones

AI landing zones

Enterprise-scale foundation for AI workloads — Foundry, networking, governance and security guardrails that the AI Gateway and agent patterns plug into.
Azure/logicapps

Logic Apps samples

Official Logic Apps repo: agent workflow samples, templates and product team examples for Standard and Consumption.

Choosing compute & orchestration quickly

NeedReach for
Connector-heavy business workflow, mixed audienceLogic Apps
Code-first orchestration, developer-ownedDurable Functions
Event handler / small API, scale to zeroFunctions (Flex)
Container microservices, Dapr, jobs, GPUContainer Apps
Classic web app / API from codeApp Service
Any API or model exposed to anyoneAPIM in front, always