Study guide

11.3 API Integration & Application Caching Design (API Management, Azure Cache for Redis, CDN)

Exam AZ-305: Designing Microsoft Azure Infrastructure Solutions Exam

Track your progress as you read

Finished sections get a check mark.

1 Introduction & Exam Orientation

1.1 AZ-305 Current Exam Facts & Format 1.2 Candidate Profile, Prerequisites & the AZ-104 Requirement 1.3 Skills Outline, Domain Weights & How to Use This Guide

2 Chapter 2: Logging, Monitoring & Diagnostics Design

2.1 Logging Solution Design 2.2 Log Routing Design 2.3 Azure Monitor Metrics & Alerting Design 2.4 Application Insights & Diagnostic Monitoring Design

3 Chapter 3: Authentication & Authorization Design

3.1 Authentication Solution Design 3.2 Identity Management Design 3.3 Authorization for Azure Resources 3.4 Authorization for On-Premises Resources 3.5 Secrets, Certificates & Key Management Design

4 Chapter 4: Governance, Compliance & Identity Governance Design

4.1 Management Group & Subscription Hierarchy Design 4.2 Resource Group Organization & Tagging Strategy Design 4.3 Compliance Management Design 4.4 Identity Governance Design

5 Chapter 5: Relational Data Storage Design

5.1 Relational Data Storage Selection 5.2 Database Service & Compute Tier Design 5.3 Database Scalability Design 5.4 Relational Data Protection Design

6 Chapter 6: Semi-Structured & Unstructured Data Storage Design

6.1 Semi-Structured Data Storage Design 6.2 Unstructured Data Storage Design 6.3 Storage Tier & Cost-Performance Trade-off Design 6.4 Unstructured Data Protection & Durability Design

7 Chapter 7: Data Integration & Analytics Design

7.1 Data Integration Pipeline Design 7.2 Event-Based & Real-Time Data Integration Design 7.3 Data Analytics Platform Design

8 Chapter 8: Backup & Disaster Recovery Design

8.1 Recovery Objectives Design: Calculating and Meeting RTO/RPO 8.2 Azure Site Recovery Architecture for Hybrid Workloads 8.3 Compute Backup & Recovery Design 8.4 Database Backup & Recovery Design 8.5 Unstructured Data Backup & Recovery Design

9 Chapter 9: High Availability Design

9.1 Compute High Availability: Availability Sets & Availability Zones 9.2 Compute High Availability: Load Balancing & VM Scale Set Design 9.3 Relational Data High Availability Design 9.4 Semi-Structured & Unstructured Data High Availability Design

10 Chapter 10: Compute Solution Design

10.1 Compute Requirements Analysis & Virtual Machine-Based Solution Design 10.2 Container-Based Solution Design (AKS, Container Apps, Azure Container Instances) 10.3 Serverless-Based Solution Design (Azure Functions, Logic Apps) 10.4 Batch Processing Solution Design (Azure Batch, HPC Workloads)

11 Chapter 11: Application Architecture Design

11.1 Messaging Architecture Design (Service Bus, Queue Storage) 11.2 Event-Driven Architecture Design (Event Grid, Event Hub) 11.3 API Integration & Application Caching Design (API Management, Azure Cache for Redis, CDN) 11.4 Application Configuration Management & Automated Deployment Design (App Configuration, DevOps Pipelines, Deployment Slots)

12 Chapter 12: Migration Design

12.1 Migration Assessment: Cloud Adoption Framework & On-Premises Evaluation 12.2 IaaS & PaaS Workload Migration Design 12.3 Database Migration Design (Data Migration Service, Database Migration Assistant) 12.4 Unstructured Data Migration Design (AzCopy, Data Box, Storage Migration Service)

13 Chapter 13: Network Solution Design

13.1 Internet Connectivity Design 13.2 Hybrid Connectivity Design 13.3 Network Security Optimization Design 13.4 Network Performance Optimization & Load-Balancing/Routing Design

14 Chapter 14: Final Review, Exam Strategy & Career Path

14.1 Cross-Domain Scenario Practice: Combining Identity, Data, Continuity & Infrastructure Decisions 14.2 Common AZ-305 Decision Traps 14.3 Final Study Plan & Practice Assessment Strategy 14.4 After AZ-305: Retake Policy, Renewal & Career Path

11.3 API Integration & Application Caching Design (API Management, Azure Cache for Redis, CDN)

Key Takeaways Explain This Topic AI

Azure API Management (APIM) is a governed facade in front of one or more backend APIs, providing throttling, subscription keys, JSON Web Token (JWT) validation, transformation policies, and a self-service developer portal regardless of where the backend actually runs.

APIM tiers range from serverless Consumption (pay-per-call) through Basic/Standard for production traffic to Premium, which adds multi-region deployment, virtual network (VNet) injection, and availability-zone support.

Azure Cache for Redis externalizes application state and hot-read data at sub-millisecond latency; Basic has no SLA, Standard adds a replicated two-node pair with a 99.9% Service Level Agreement (SLA), and Premium adds clustering, persistence, VNet deployment, and geo-replication.

Redis caches dynamic, per-key application data close to compute; a Content Delivery Network (CDN) or Azure Front Door caches static or cacheable HTTP responses at edge points of presence close to end users worldwide — they solve different caching problems and are often used together.

Externalizing session state to Redis is required whenever a web tier must scale out across multiple instances or survive instance recycling, because in-process session state is lost the moment a request lands on a different instance.

Last updated: October 2026

Why API Integration and Caching Design Matter on AZ-305

Microsoft groups "Recommend a solution for API integration" and "Recommend a caching solution for applications" under the same Design infrastructure solutions (30-35%) application-architecture subgroup, and this guide follows suit because the two decisions are closely linked in practice: Azure API Management's own response-cache policy is often the first caching lever an architect reaches for before standing up a dedicated cache. AZ-305 tests whether you can (1) choose the right way to expose and govern a set of APIs, and (2) choose the right caching tier for a given latency, durability, and scale requirement — rather than defaulting to "just add Redis" for every performance problem.

Core Concepts: API Management

Azure API Management (APIM) is a managed gateway that sits in front of one or many backend APIs, regardless of where those backends actually run — App Service, AKS, Functions, or even on-premises through a self-hosted gateway.

Throttling and quotas : rate-limit and quota policies protect backends from traffic spikes and enforce fair use per subscriber.

Subscription keys and security policies : APIM issues subscription keys per consumer and can enforce OAuth2 flows or a validate-jwt policy to check bearer tokens before a request ever reaches the backend.

Transformation policies : rewrite headers, convert XML to JSON (or the reverse), or reshape a request/response without changing backend code.

Products and Groups : bundle one or more APIs into a "Product" with its own visibility and terms, so public developers, partners, and internal teams can each see a different, appropriately scoped slice of the same underlying APIs.

Versioning and revisions : version sets support breaking changes (via path, header, or query-string versioning); revisions support safe, non-breaking iteration with the ability to roll back.

Developer Portal : a self-service portal where external or partner developers can discover APIs, read documentation, and generate their own subscription keys without opening a ticket.

Built-in response caching : a lightweight cache policy for repeatable GET responses, avoiding the need to stand up a separate cache just for API-level caching.

Self-hosted gateway : a containerized version of the APIM gateway that can run on-premises or in another cloud while the management plane stays in Azure — the answer whenever a hybrid or edge API-governance scenario appears.

Tiers : Consumption is serverless and billed per call, ideal for lightweight or intermittent APIs but without the SLA guarantees of dedicated capacity; Developer is for non-production evaluation only (no SLA); Basic and Standard provide fixed production capacity units; Premium adds multi-region deployment, VNet injection for full network isolation, availability-zone support, and the highest scale ceiling. A newer "v2" tier line (Basic v2, Standard v2, Premium v2) simplifies scaling for teams that do not need every classic-tier feature.

Core Concepts: Caching

Azure Cache for Redis is a managed, in-memory data store delivering sub-millisecond reads for data that would otherwise require a round trip to a database or backend service.

Basic — a single node with no SLA; development and testing only.

Standard — a two-node, replicated pair with automatic failover and a 99.9% SLA; the practical minimum for any production workload.

Premium — adds clustering (for larger datasets and higher throughput), data persistence via RDB snapshots or an append-only file (AOF), VNet deployment, zone redundancy, and geo-replication for disaster recovery.

Enterprise and Enterprise Flash — built on the Redis Enterprise engine, adding modules such as RediSearch and RedisJSON, active geo-replication, and higher availability targets than Premium.

Common uses: externalizing session state so any instance behind a load balancer can serve any user (critical the moment a web tier scales out horizontally or an instance is recycled during a deployment or autoscale event); a look-aside cache for expensive or frequently repeated database reads; distributed locks; lightweight pub/sub signaling; and leaderboard-style sorted-set data structures. Eviction policy (for example, allkeys-lru , evicting the Least Recently Used key regardless of type, versus volatile-lru , evicting only keys with an expiration set) determines what Redis discards under memory pressure, and must be chosen based on whether every key is disposable cache data or some keys must never be evicted.

A Content Delivery Network (CDN) or Azure Front Door solves a different caching problem: rather than caching per-key application data close to compute, it caches cacheable HTTP responses — images, video, scripts, and eligible API GET responses — at edge points of presence (PoPs) physically close to end users around the world, cutting both latency and origin load for globally distributed traffic. Redis and CDN are frequently used together: Redis at the application/data tier, CDN/Front Door at the network edge.

Layer Service Caches Scope Latency profile

Application/data tier Azure Cache for Redis Session state, query results, computed values Per-region, application-aware Sub-millisecond

API tier APIM built-in cache Repeatable GET responses Per API operation Milliseconds

Network edge Azure Front Door (or an existing Azure CDN classic profile) Static assets, cacheable HTTP responses Global, PoP-distributed Tens of milliseconds, closest PoP

Decision Framework

Externalize session state for a web tier that scales out or is redeployed frequently → Azure Cache for Redis , Standard tier minimum for the SLA.

Reduce read pressure on a hot relational table without changing the database tier → Redis as a look-aside cache .

Serve static or globally cacheable content with the lowest latency to users worldwide → Azure Front Door (Azure CDN from Microsoft (classic) accepts no new profiles since August 15, 2025 and retires September 30, 2027).

Expose many backend microservices behind one governed entry point with throttling, security policy enforcement, and developer self-service → API Management .

Need a hybrid or on-premises API gateway with centralized cloud-based policy management → APIM self-hosted gateway .

Exam Scenario

A company has 12 internal microservices that must be exposed to external partner developers, each partner needing its own rate limit and API key, plus a self-service portal for onboarding, and repeated product-catalog GET requests should be cached for five minutes to reduce backend load. The correct design is API Management (Standard or Premium tier depending on scale and isolation needs) with one Product per partner , subscription keys , and a response-caching policy on the catalog operation.

A second scenario: an e-commerce site's shopping-cart data must survive both autoscale events and a deployment-slot swap across multiple App Service instances, with automatic failover, while the team also wants to shave milliseconds off repeated product-catalog reads. The correct design is Azure Cache for Redis (Standard tier at minimum for the SLA, Premium if geo-replication or persistence is also required) used both for externalized session state and as a look-aside cache for the catalog reads.