Assumptions to confirm
- One organizational Entra tenant and an existing Azure landing zone with separate connectivity and workload ownership.
- Corporate clients reach the application spoke through private connectivity; a public customer portal is outside this design.
- The baseline uses customer-managed App Service orchestration and push indexing, not a managed Foundry agent runtime.
- Document sources provide an authoritative permission and deletion feed; unresolved permissions fail closed.
- Region, model deployment type, quota and recovery targets are selected before procurement.
This reference design uses private App Service applications, an API Management gateway, Azure AI Search and Azure OpenAI inference. The application owns retrieval authorization. It is a proposed enterprise configuration, documentation-reviewed rather than deployed or load-tested; the private request view shows managed services outside the customer VNet, with private endpoints and integration subnets inside it.
The three views separate the private request path, identity and release authority, and content publication and recovery. Together they retain links F1-F16; repeated retrieval links provide context in the identity view. The procedures below expand those paths.
Deployment decisions and component responsibilities
Place application resources in a workload subscription governed by the landing zone. Reuse approved hub connectivity, DNS and egress services where ownership and capacity permit. Keep source systems authoritative; the search index is a derived copy, not the document system of record.
| Component | Selected configuration | Security responsibility |
|---|---|---|
| Employee web UI | App Service Premium v3, private endpoint, public ingress disabled | Present citations and obtain tokens for the application API. |
| Application gateway | APIM Standard v2, inbound private endpoint plus outbound VNet integration | Validate tenant, audience and API scopes; impose request and token budgets. |
| Retrieval API | Separate App Service app and managed identity | Derive principal set, enforce document filters and minimize model context. |
| Ingestion worker | Separately deployed worker with its own identity | Validate source, content version, permission version and deletion events. |
| Search | Billable Standard service, independent reader/writer roles | Store chunks, vectors, source identifiers and authorization metadata. |
| Storage | Separate quarantine and approved Blob containers or accounts | Prevent unapproved objects becoming retrievable evidence. |
| Inference | Azure OpenAI resource, approved deployment and private endpoint | Receive only selected authorized context. |
| Shared controls | Key Vault, Private Resolver, Firewall, Monitor | Protect credentials, name resolution, egress and operational evidence. |
App Service private endpoints cover inbound traffic; outbound VNet integration uses a different subnet. Private endpoints do not themselves disable public access, and App Service access restrictions are not evaluated on private-endpoint traffic. Include deployment-slot and SCM connectivity in the private deployment design. App Service boundaries.
For APIM, Standard v2 provides the selected combination of inbound Private Link and outbound integration. Private Link covers the gateway endpoint, not every administrative surface. Integration alone does not privatize ingress. Allocate the documented dedicated integration subnet, preserve service dependencies, and qualify region availability. The v2 gateway also requires a publicly resolvable DNS name; that requirement does not mean public data-plane access must remain enabled. Private endpoint limits, integration requirements.
Numbered request and identity flow
- A managed employee device reaches the private UI through ExpressRoute or VPN. Corporate DNS forwards the relevant Azure private-name resolution through the hub resolver. Entra sign-in follows its approved identity-service route; it is not assumed to be private merely because the application is private.
- The client obtains an access token for the retrieval API. APIM validates the token and passes it to that same API audience. The API independently validates issuer, tenant, audience, expiry and required scope; network reachability is insufficient authorization.
- The API derives tenant and user identifiers from validated claims and resolves authorized groups through a trusted server-side path. Missing group claims, group overage, stale membership or resolution failure must not become unrestricted search. Bound caching to the agreed revocation interval.
- The API creates the mandatory document filter and calls Search with its query-only managed identity. Caller-supplied principal lists, index names and filter fragments are not accepted as authority.
- Only authorized chunks enter the prompt. Treat their text as untrusted evidence, cap context size, and return source references through a citation endpoint that rechecks access.
- The API obtains a model-service token using its workload identity and invokes the selected deployment. That token represents the workload, not the employee. If a downstream API must enforce the employee’s own rights, implement a supported delegated/OBO path instead.
OBO exchanges a user token for a token intended for a downstream API; it does not convert an app-only identity into user delegation. Acquire the correct audience through MSAL rather than forwarding a token to an unrelated service. Microsoft OBO model.
For the dedicated Azure OpenAI resource selected here, grant the runtime only the inference role it needs at that resource. Cognitive Services OpenAI User can invoke deployed models without deployment-management privileges; it is not a per-user document entitlement or an isolated grant to one model deployment. Use separate resources when that administrative boundary is necessary. Foundry project roles require their own resource-type review. Azure OpenAI role scope.
Document authorization is an application invariant
The baseline uses a filterable collection of source-derived allowed principal identifiers, plus tenant, source version and permission version. Microsoft describes ordinary security filters as string comparison, not built-in identity authorization. The application must therefore apply the filter to every exposed retrieval path. A non-retrievable permission field is not a security boundary. Security-filter semantics.
Expose a deliberately narrow API. Do not offer unrestricted search, lookup, autocomplete, facets, raw vector results or direct browser access to Search. Include tenant, entitlement version and document version in cache keys; invalidate cached answers when their evidence loses authorization. A citation URL must not become an alternate download path around the original decision.
Separate query and ingestion identities. Search Index Data Reader queries content; Search Index Data Contributor writes content. Resource-management roles and indexer privileges need separate scrutiny, and per-index role assignments do not constrain indexers in the same way as direct API calls. Use separate search services when administrative isolation between collections is required. Search role boundaries.
Built-in ACL/RBAC, SharePoint ACL ingestion and sensitivity-label enforcement are documented preview alternatives. Their source, API/SDK and synchronization requirements differ; they are not an automatic property of every index. Query-time enforcement relies on indexed permission metadata and a documented user-authorization mechanism. Evaluate that design separately, including group expansion and permission freshness, before replacing the baseline. Access-control options, query enforcement qualifications.
Numbered ingestion and permission-update flow
- An approved source exporter submits content plus a signed or otherwise authenticated manifest containing source ID, version, hash and authoritative permissions. Write first to quarantine; the query identity cannot read this area.
- A constrained worker checks file type, size, malware-scanning outcome and parser limits. Failed or incomplete inspection stays quarantined. Scanning does not establish that document instructions are trustworthy.
- The worker creates bounded chunks, preserves provenance and attaches complete permission metadata to every chunk. Generate embeddings with a separately permitted workload identity; embedding generation also sends document content to a model service.
- Publish approved content and index records as a versioned release. Readers see only a complete active version. Missing permissions, orphan chunks and mismatched versions fail closed.
- Process permission reductions and deletions with priority. Apply a temporary deny record when the normal update pipeline cannot meet the revocation objective, then reconcile the index and caches. Measure lag from the authoritative change, not just from the most recent successful indexing run.
These publication and revocation rules are application design requirements. A successful index operation does not demonstrate source-permission fidelity.
Network, model and telemetry boundaries
Use private endpoints for Search, storage, Key Vault and the model resource, with public data ingress explicitly disabled after validation. Link the right private zones to the client and workload paths. Test DNS from the employee, API, ingestion worker and deployment runner; a successful lookup from an administrator’s laptop proves little about the runtime. Hybrid private DNS pattern.
Route applicable workload egress through the approved firewall and inventory identity, certificate, package and monitoring dependencies. Private Link does not constrain every outbound call or every managed-service tool. This design does not deploy Foundry Agent Service. If that becomes a requirement, assess inbound access, agent outbound networking and tool-specific dependencies separately. Classic hub managed-network instructions explicitly do not apply to new Foundry projects. Foundry network scope, classic applicability.
Model deployment type determines processing geography. Global, Data Zone and geography-based options are different choices; a private endpoint does not change those processing commitments. Confirm model/version availability and allocated quota in both primary and recovery locations. Deployment-type distinctions.
The telemetry flow is API/worker spans to Application Insights and operational metrics to Monitor/Log Analytics, with security signals routed to the SOC. Record correlation ID, policy version, pseudonymous principal reference, authorization outcome, chunk count, dependency latency, token usage and revocation lag. Do not collect full prompts, responses, source text, bearer tokens or URL query contents by default. Filter before export, and test exceptions and SDK instrumentation for leakage. Ingestion-time transformations act after Azure receives telemetry. Telemetry filtering.
Recovery, acceptance and operating cost
- Preserve approved source versions, manifests, index definitions, application releases and policy configuration in recoverable stores with named owners.
- Recreate the service in the approved recovery region and rebuild the index from authoritative data. Search provides no self-service native backup/restore; test the rebuild duration and validate permissions before reopening queries.
- Restore DNS, private endpoints, identities, role assignments and model capacity. Re-run negative authorization tests before routing users.
For Search availability, Microsoft requires two replicas for the read-only SLA and three for read/write workloads. Continuous ingestion makes the latter relevant. Replicas do not provide independent regional recovery. Search reliability and rebuilding.
| Threat or failure test | Release acceptance evidence |
|---|---|
| Forged group, tenant or filter input | Request rejected or ignored; no unauthorized chunk returned. |
| Revoked source permission | Direct retrieval, cached answer and citation access denied within the agreed interval. |
| Malicious or partially parsed document | No unapproved chunk enters the active index. |
| DNS failure or public-endpoint attempt | Explicit failure; no hidden public fallback. |
| Missing authorization dependency | Query fails closed rather than dropping the filter. |
| Region recovery | Timed rebuild, model-capacity check and repeated access tests pass. |
Pilot with synthetic documents, then a bounded business collection. The platform team owns networking and deployment; data owners own permissions and deletion feeds; the application team owns filtering and cache invalidation; the SOC owns alert routing and evidence access. Record unresolved exceptions before expanding access.
Budget for always-on App Service/APIM capacity, Search replicas and partitions, private endpoints, firewall/DNS, model tokens, ingestion reprocessing and log retention. Sharing an approved hub reduces duplication; sharing application plans or indexes increases contention and administrative coupling. Choose those tradeoffs explicitly. This architecture supplies no cost estimate or recovery guarantee without workload sizing and measured validation.
Trace the design decisions
Microsoft architecture & product guidance
- Microsoft Learn - App Service private endpoints ↗
- Microsoft Learn - API Management inbound private endpoint ↗
- Microsoft Learn - API Management outbound VNet integration ↗
- Microsoft Learn - Azure AI Search security filter pattern ↗
- Microsoft Learn - Azure AI Search document access options ↗
- Microsoft Learn - Azure AI Search query-time permission enforcement ↗
- Microsoft Learn - Azure AI Search RBAC ↗
- Microsoft Learn - Entra on-behalf-of flow ↗
- Microsoft Learn - Microsoft Foundry private networking ↗
- Microsoft Learn - Classic Foundry hub managed networks ↗
- Microsoft Learn - Foundry model deployment types ↗
- Microsoft Learn - Azure AI Search reliability ↗
- Microsoft Learn - Private Resolver for on-premises workloads ↗
- Microsoft Learn - Filter OpenTelemetry in Application Insights ↗
- Microsoft Learn - Azure OpenAI resource role scope ↗