Blog Post

Azure Infrastructure Blog
18 MIN READ

Designing GitHub Actions Runners on Private AKS with a Secured Azure Virtual WAN Hub

Gapandey's avatar
Gapandey
Icon for Microsoft rankMicrosoft
Nov 18, 2026

Self-hosted GitHub Actions runners can execute workflows close to private deployment targets without making those targets publicly reachable. That network access also makes the runner environment part of the security boundary. A workflow can use the connectivity and credentials available to its runner, so private connectivity needs to be considered alongside outbound access, repository permissions, and workload isolation.

A private Azure Kubernetes Service (AKS) cluster protects access to the Kubernetes API through private networking. It does not, by itself, restrict all traffic leaving the nodes or runner pods. In this single-region design, the AKS virtual network connects to a secured Azure Virtual WAN hub. Azure Firewall applies destination-based policies to Internet-bound connections, while authorized administrators reach the private API from a management host with the required network access.

Actions Runner Controller (ARC) manages ephemeral runners as Kubernetes pods and adjusts runner capacity to the jobs assigned by GitHub Actions. A dedicated user node pool separates runner execution from the pool selected for the controller and listener. Runner-pod scaling and AKS node scaling remain different mechanisms, with separate capacity and operational considerations.

The design brings together private API access, controlled GitHub egress, runner authentication, and firewall logging. Network-isolated AKS with a managed bootstrap cache and GitHub App authentication are selected options, not universal requirements for every private runner deployment. The sections below explain those choices and link their commands and configuration settings to official Microsoft and GitHub sources.

Overall connectivity

Figure 1. Overall connectivity for GitHub Actions runners on private AKS with a secured Azure Virtual WAN hub.

The four numbered paths show how the environment is managed, reaches GitHub, retrieves bootstrap artifacts, and records firewall activity:

  1. Administrators reach the management VM through Azure Bastion or approved private access, then manage AKS through its private Kubernetes API.
  2. The ARC controller, listener, and runner pods initiate outbound HTTPS connections to GitHub through the secured hub and Azure Firewall. No inbound GitHub job webhook is configured.
  3. AKS nodes retrieve bootstrap artifacts through the private ACR endpoint. This cache does not replace GitHub Container Registry access for runner images.
  4. Azure Firewall sends diagnostic logs to Log Analytics so operators can investigate allowed and denied connections.

The private API and bootstrap-cache paths do not traverse the hub firewall. Management-tool Internet access and connections to deployment targets are not shown.

Architecture scope and validation

The architecture and configuration examples cover:

  • Private Kubernetes API access from an authorized management host, without a public API endpoint
  • Internet-bound spoke traffic routed through the secured hub and GitHub-specific firewall application rules
  • ARC configuration and a manually triggered workflow targeting a dedicated runner node pool
  • Firewall evidence for allowed GitHub connections and controlled denied connections
  • Ephemeral runner lifecycle and its distinction from AKS node autoscaling

The baseline uses GitHub.com, Azure public cloud, Linux nodes, organization-scoped runner registration, and shell-only workflow steps. It does not configure container builds, production deployment credentials, or hostile multi-tenant isolation.

The command blocks explain configuration rather than direct deployment. A documented command or setting does not establish that the complete combination has been validated in a particular subscription, region, or security environment. Expected results below are validation criteria, not results from an executed deployment.

The command blocks explain configuration rather than direct deployment. A documented command or setting does not establish that the complete combination has been validated in a particular subscription, region, or security environment. Expected results below are validation criteria, not results from an executed deployment.

Prerequisites and assumptions

The configuration examples assume:

  • An Azure subscription with the permissions required for the network, firewall, AKS cluster, managed identity, and scoped role assignments
  • Sufficient regional VM quota and an approved budget for Azure Firewall, Virtual WAN, AKS nodes, the private bootstrap registry, monitoring, and management services
  • A GitHub organization and private repository, with a plan that supports creating the additional restricted runner group used here, such as GitHub Team or GitHub Enterprise
  • Permission to configure an approved ARC authentication method; the example chooses an organization-owned GitHub App
  • An approved Linux management host with private access to the AKS spoke, Azure CLI 2.73.0 or later, Helm 3, a compatible kubectl, kubelogin, and Bash
  • Outbound access from that management host to Azure sign-in and management services and GitHub's OCI chart distribution endpoints

The host can be a VM in the spoke's management subnet, accessed through Azure Bastion or an existing approved private connection. A public SSH endpoint is not part of this design. A default, unconnected Cloud Shell session does not provide private cluster access. See private AKS connectivity guidance, Azure Bastion connectivity, and runner-group availability and access.

Command blocks illustrate configuration from that Bash host. They are not intended for direct execution without environment-specific review. Private keys and tokens do not belong in repositories, terminal history, or published screenshots.

[!WARNING] Setting runner capacity to zero does not stop firewall, hub, registry, monitoring, or system-node charges. These services have independent pricing and capacity requirements.

Step 1: Network and AKS egress model

Azure CNI Overlay separates node addressing from pod addressing. Nodes receive IP addresses from their VNet subnets, while pods use a separate CIDR range. Each additional runner pod therefore does not consume another VNet subnet address. This conserves spoke address space as runner capacity grows. See Microsoft's Overlay subnet-sizing guidance.

The address plan separates the hub, node pools, management access, pod network, and Kubernetes services:

  • Secured virtual hub: 10.60.x.x/22, for Virtual WAN hub services and Azure Firewall
  • AKS spoke VNet: 10.61.x.x/16, for nodes and private management
  • System node subnet: 10.61.x.x/24, for AKS services and the selected ARC controller and listener placement
  • Runner node subnet: 10.61.x.x/23, for the dedicated Linux user node pool
  • Management subnet: 10.61.x.x/24, for the approved private administration host
  • AzureBastionSubnet, if used: 10.61.x.x/26, separate from the management subnet
  • Overlay pod address space: 10.62.x.x/16
  • Kubernetes service range: 10.63.x.x/24, with a DNS service IP represented as 10.63.x.x

Size each node subnet for that pool's maximum node count, additional nodes used during surge upgrades, and any other resources consuming addresses from the subnet. Azure reserves five addresses in each subnet, leaving 251 usable addresses in a /24 before resources are allocated. Sizing only for the initial nodes can leave insufficient addresses for scaling or upgrades. See Overlay node-subnet planning and AKS upgrade and scaling considerations.

Size the pod CIDR for nodes across both the system and runner pools, including temporary surge nodes. Overlay allocates a fixed /24 pod block to every node; lowering maxPods does not shrink that block. The networking model supports up to 250 pods per node, but that is not a recommendation to place 250 CI runners on one node. An ARC runner-pod limit does not replace node-level address planning. See Overlay pod allocation.

Choose a supported RFC 1918 or RFC 6598 pod range that does not overlap node subnets or connected networks. An overlap with a destination network can make that destination unreachable from pods even when the firewall allows it. Keep the Kubernetes service CIDR separate from the pod, node, and connected-network ranges. The DNS service IP must be inside the service CIDR and must not use its first service address. See Overlay address-planning requirements and AKS reserved-range restrictions.

Network-isolated AKS with outbound type none

The example selects a private, network-isolated AKS cluster with an AKS-managed bootstrap artifact cache and outboundType: none. Network isolation is an additional choice beyond a private API endpoint, not a prerequisite imposed by ARC or Virtual WAN.

Microsoft documents that none does not create an AKS egress path or require a default route during validation, and supports bring-your-own VNets. Required egress is supplied explicitly through a firewall, proxy, gateway, or other network component. Here, that component is the secured Virtual WAN hub. The private cache supplies AKS bootstrap images; GitHub traffic still needs the firewall path described below.

This is a different AKS outbound model from userDefinedRouting, not a claim that a vWAN-propagated default satisfies UDR validation. The userDefinedRouting model has its own node-subnet route-table requirements and is not an interchangeable option in the example.

See AKS outbound types, network-isolated AKS, and the managed-cache creation guide.

A conventional private AKS cluster can instead use another documented outbound model and permit its required AKS dependencies through the chosen egress controls. Changing to that model requires a different configuration and endpoint review; removing the cache flags from this example is not an equivalent substitution.

Step 2: Secured hub and spoke connectivity

The example separates networking into rg-arc-network and the cluster and identity into rg-arc-aks. The resources use the same selected region.

The configuration consists of:

  1. A Standard Virtual WAN with a secured virtual hub and Azure Firewall Standard. Azure Firewall Manager exposes the secured-hub creation flow. The /22 address-space choice accommodates Microsoft's documented Azure Firewall scaling requirement in virtual hub address-space settings. VPN and ExpressRoute gateways are separate requirements when the management design uses them.
  2. An associated Firewall Policy with default-deny behavior, rather than an unrestricted outbound allow.
  3. A spoke named vnet-arc-spoke, with system subnet snet-aks-system, runner subnet snet-aks-runners, and management subnet snet-management. The AKS node subnets are not delegated to another service.
  4. A Virtual WAN > Virtual network connections connection between the hub and spoke. This is not VNet peering to a customer-managed hub VNet.
  5. Azure-provided DNS for the baseline, with the management host in the same VNet as the AKS nodes.
  6. Intra-cluster connectivity consistent with Azure CNI Overlay requirements. NSGs must account for required communication between the system and runner subnets.

The official secured cloud network tutorial documents the portal creation flow. Resource names and some blade labels can vary as the portal evolves.

Figure 2. Secured Virtual WAN foundation.

Step 3: GitHub egress policy and logging

The associated Firewall Policy > Rule collection groups contains an Application rule collection with action Allow, for example at priority 200. The rules use HTTPS:443 and target FQDNs.

Rule sources are the system and runner subnet CIDRs, represented here as 10.61.x.x/24 and 10.61.x.x/23. The controller and listener need GitHub connectivity as well as the runner pods. With Azure CNI Overlay, traffic leaving the cluster is translated to node addresses, rather than using the overlay pod CIDR as the firewall source for these flows.

The following destinations are a subset of GitHub's documented domains, grouped by function. Essential service traffic and the chart and image pulls used here need their corresponding rules. Action, artifact, package, and release functions need the relevant destinations when those functions are used; the table is not a claim that every job needs every row.

Rule purposeGitHub-documented target FQDNs
Actions service and APIgithub.com, api.github.com, *.actions.githubusercontent.com
Action downloadscodeload.github.com
Logs, artifacts, cacheresults-receiver.actions.githubusercontent.com, *.blob.core.windows.net
Runner updatesobjects.githubusercontent.com, objects-origin.githubusercontent.com, github-releases.githubusercontent.com, github-registry-files.githubusercontent.com
GitHub container assetsghcr.io, *.pkg.github.com, pkg-containers.githubusercontent.com
Release downloadsrelease-assets.githubusercontent.com

GitHub lists the required domains by function in its accessible-domain reference. Its documentation notes that some firewalls require recursive rules for CNAME records, whose targets can change while the listed domains remain constant. Workflows may also require access to other network resources. Git LFS and Dependabot have additional domain entries in that reference and are outside this baseline.

The public Blob wildcard is broad. It is a documented GitHub dependency, not an exfiltration-prevention guarantee. It also does not replace private-endpoint DNS or storage authorization.

Management-host rules are separately scoped to approved Azure and GitHub tooling needs. Management-host sign-in is not a reason to broaden node permissions. Adding a private endpoint's public hostname to an Internet allow rule does not establish private endpoint reachability.

For this network-isolated baseline, public AKS bootstrap exceptions from a conventional firewall tutorial are not automatically applicable. Additional services and add-ons have their own network-isolated feature dependencies and AKS outbound requirements.

Rule evaluation and inspection depth

Azure Firewall evaluates network rules before application rules. An Any destination / TCP 443 network allow can therefore bypass the intended application FQDN restriction. Inherited policies also affect evaluation. See rule processing.

Standard performs SNI-based HTTPS destination filtering. It does not decrypt HTTPS payloads. Premium TLS inspection is a separate design, including certificate trust in nodes, controller, listener, runners, and tools that make inspected connections. See features by SKU.

Diagnostic configuration

Diagnostic settings belong to the Azure Firewall resource, not only the policy. The configuration includes:

  1. Application-rule and network-rule logs sent to an approved Log Analytics workspace
  2. Resource specific destination tables for the query example below
  3. DNS-proxy logs when DNS proxy is enabled
  4. Appropriate retention and access controls for network and workflow-related evidence

Resource logs are not retained for query until a diagnostic destination is configured. See Azure Firewall monitoring.

Step 4: Routing intent and the default path

The routing configuration includes:

  1. Internet Traffic routing intent with the hub's Azure Firewall as next hop
  2. The applicable Internet security / default-route propagation setting enabled on the spoke connection
  3. Private Traffic left unconfigured in this baseline; supported inter-spoke or hybrid private inspection is a separate policy decision
  4. Gateway-route propagation enabled on any relevant spoke subnet route table
  5. Effective routes showing the spoke's Internet default toward the virtual hub and the hub's Internet policy selecting Azure Firewall

The NIC next-hop display need not show the firewall's private IP directly. The spoke-to-hub and hub-to-firewall parts need to be considered together. An unexplained manual default route to the secured-hub firewall is not part of this example.

See routing intent configuration and troubleshooting and NIC effective routes.

The evidence described in Step 10 includes matching firewall records. A configured policy or a successful HTTPS request alone does not prove that the request traversed the firewall.

Step 5: Private AKS and the managed bootstrap cache

The managed bootstrap cache is not mandatory for every private AKS cluster. It is the selected bootstrap option for the network-isolated Cache plus none model used here. Microsoft also documents a bring-your-own private ACR option. ARC itself requires a suitable Kubernetes cluster, not an AKS bootstrap cache. See Microsoft's network-isolated cluster options and GitHub's ARC prerequisites.

An existing suitable cluster does not need to be recreated for ARC. The creation example below applies only when provisioning the selected cluster model; it is not a migration procedure for an existing cluster.

The Bash examples adapt Microsoft's documented commands to the resource names and choices in this design. The resource groups, VNet, subnets, hub connection, and firewall configuration are assumed to exist. CIDRs and the DNS service IP remain placeholders. The combined sequence is not ready-to-run deployment instructions.

The following block uses Azure sign-in, subscription selection, VNet lookup, and Microsoft's private-subnet configuration example. The variable names and grouping are adaptations.

export SUBSCRIPTION_ID="<subscription-id>"
export LOCATION="<azure-region>"
export NETWORK_RG="rg-arc-network"
export WORKLOAD_RG="rg-arc-aks"
export VNET_NAME="vnet-arc-spoke"
export AKS_NAME="aks-arc"
export POD_CIDR="<pod-cidr>"
export SERVICE_CIDR="<service-cidr>"
export DNS_SERVICE_IP="<dns-service-ip>"

az login
az account set --subscription "$SUBSCRIPTION_ID"

VNET_ID=$(az network vnet show \
  --resource-group "$NETWORK_RG" --name "$VNET_NAME" \
  --query id --output tsv)

SYSTEM_SUBNET_ID="${VNET_ID}/subnets/snet-aks-system"
RUNNER_SUBNET_ID="${VNET_ID}/subnets/snet-aks-runners"

az network vnet subnet update \
  --resource-group "$NETWORK_RG" --vnet-name "$VNET_NAME" \
  --name snet-aks-system --default-outbound false

az network vnet subnet update \
  --resource-group "$NETWORK_RG" --vnet-name "$VNET_NAME" \
  --name snet-aks-runners --default-outbound false

The private-subnet setting removes reliance on implicit default outbound access. It does not block explicit firewall egress and is separate from making the AKS API private. This example sets it before creating nodes. For existing VMs, Microsoft documents that a stop and deallocation is required for subnet changes to take effect on their interfaces; this is not guidance to modify AKS-managed VM instances directly. See default outbound access guidance.

Control-plane identity

The user-assigned control-plane identity has Network Contributor on the example VNet. The VNet scope also supports the private DNS VNet-link operation; this is not a subscription-wide grant. Role-assignment and identity-use permissions are separate deployment prerequisites.

The commands adapt user-assigned managed identity creation, AKS VNet permissions, role-assignment syntax, and regional Kubernetes version lookup.

AKS_IDENTITY_ID=$(az identity create \
  --resource-group "$WORKLOAD_RG" --name id-aks-arc \
  --location "$LOCATION" \
  --query id --output tsv)

AKS_IDENTITY_PRINCIPAL_ID=$(az identity show \
  --ids "$AKS_IDENTITY_ID" --query principalId --output tsv)

az role assignment create \
  --assignee-object-id "$AKS_IDENTITY_PRINCIPAL_ID" \
  --assignee-principal-type ServicePrincipal \
  --role "Network Contributor" --scope "$VNET_ID"

az aks get-versions --location "$LOCATION" --output table
export KUBERNETES_VERSION="<supported-regional-kubernetes-version>"

Role assignments have propagation delays. The Kubernetes version also needs to be a currently supported regional release, not an obsolete release merely because it exceeds the network-isolated minimum. See AKS managed identities.

Cluster configuration example

Microsoft's AKS-managed ACR creation example explicitly includes --bootstrap-artifact-source Cache, --outbound-type none, and --enable-private-cluster. The longer command below combines that example with documented private DNS and public-FQDN options, Overlay options, and Microsoft Entra authorization.

All remaining switches are described in the official az aks create reference. The selected node name, VM size, count, disk type, and maximum pods are example choices, not a Microsoft-prescribed ARC configuration.

az aks create \
  --resource-group "$WORKLOAD_RG" \
  --name "$AKS_NAME" \
  --location "$LOCATION" \
  --kubernetes-version "$KUBERNETES_VERSION" \
  --assign-identity "$AKS_IDENTITY_ID" \
  --enable-private-cluster \
  --disable-public-fqdn \
  --private-dns-zone system \
  --bootstrap-artifact-source Cache \
  --outbound-type none \
  --network-plugin azure \
  --network-plugin-mode overlay \
  --pod-cidr "$POD_CIDR" \
  --service-cidr "$SERVICE_CIDR" \
  --dns-service-ip "$DNS_SERVICE_IP" \
  --vnet-subnet-id "$SYSTEM_SUBNET_ID" \
  --vm-set-type VirtualMachineScaleSets \
  --load-balancer-sku standard \
  --nodepool-name systempool \
  --node-count 2 \
  --node-vm-size Standard_D4s_v5 \
  --node-osdisk-type Managed \
  --os-sku Ubuntu \
  --max-pods 30 \
  --node-os-upgrade-channel NodeImage \
  --enable-aad \
  --enable-azure-rbac \
  --disable-local-accounts \
  --generate-ssh-keys

Omitting a bootstrap registry resource ID selects the documented AKS-managed cache path. AKS manages its bootstrap registry, cache rules, and private connectivity. The default cache supplies Microsoft bootstrap images; it does not automatically mirror the GHCR controller and runner images. Those pulls need the GitHub egress rules from Step 3.

The two-node system pool is an illustrative minimum, not a production availability recommendation. Capacity needs to account for AKS services, the ARC controller, and the listener. Microsoft recommends three system nodes for production. See system-pool requirements, the network-isolated creation guide, and the CLI parameter reference.

Installer access and private DNS

The authorization and connectivity requirements are separate:

  1. Azure Kubernetes Service RBAC Cluster Admin, scoped to the cluster, is one broad built-in role that permits the approved installer to install ARC CRDs and cluster-scoped RBAC. It is not a requirement to give every operator permanent cluster-admin access.
  2. Cluster-user credential retrieval requires the corresponding management permission, such as Azure Kubernetes Service Cluster User Role when not already covered.
  3. Assignment propagation affects access availability. These installer permissions are not workflow permissions.
  4. The management host needs private API resolution and network reachability independently of its credentials.

The credential and connection commands adapt private-cluster connectivity checks and kubelogin's Azure CLI authentication example. The DNS lookup uses the documented nslookup check.

The expected state is private API resolution and nodes marked Ready. With Azure-provided DNS, AKS's default API private-zone link to the node VNet supplies API resolution. Registry resolution is a separate check: inspect the AKS-created bootstrap registry, its private endpoint, and the relevant private DNS records and VNet links. Both registry login and data-endpoint names must resolve to the intended private endpoints. Do not assume successful API resolution also verifies registry DNS.

Private API or bootstrap-image failures are distinct from ARC installation failures. Relevant references are private-cluster DNS, network-isolated troubleshooting, and Microsoft Entra authorization for AKS.

Step 6: Dedicated runner user pool

The configuration separates runner execution from the pool selected for the controller and listener. The runner pool is a Linux User pool on its own subnet, with a taint and Cluster Autoscaler bounds. This pool separation is a design choice, not an ARC installation requirement.

The command combines documented dedicated-subnet Overlay configuration, taints and tolerations, and node-pool parameters. The node count, VM size, taint value, and autoscaler bounds are illustrative.

The Helm values in Step 8 combine a runner-pool selector with the matching toleration. A toleration alone permits placement; it does not require that placement.

ARC scales runner pods. Cluster Autoscaler supplies node capacity for unschedulable pods. Their limits are independent, and neither is a hard spending cap. See AKS Cluster Autoscaler and node-pool commands.

Step 7: GitHub authentication and repository access

A GitHub App is recommended, not mandatory, for repository- or organization-scoped ARC registration. GitHub also documents personal access token authentication, including classic and fine-grained tokens. Enterprise-level runner registration does not support GitHub App authentication; GitHub's ARC quickstart specifies a personal access token (classic) for that scope. See ARC authentication methods and the ARC quickstart.

This example retains the recommended organization-owned GitHub App option. Its configuration includes:

  1. Organization permissions > Self-hosted runners: Read and write and Repository permissions > Metadata: Read-only. The documented repository Administration: Read and write permission applies to repository-scoped registration, not the organization-scoped configuration used here.
  2. An App installation in the organization, with its App ID, installation ID, and private key held securely outside the repository.
  3. A runner group named arc-private, restricted to the intended private repository. App installation scope is not a substitute for runner-group access control.
  4. GitHub credentials held in a Kubernetes Secret in the runner scale-set namespace.

ARC scale-set job delivery uses outbound HTTPS long polling. A public inbound job webhook is not required by this mechanism; a separate integration can have different requirements. This flow is described in GitHub's ARC architecture.

The Secret command adapts GitHub's documented file-based private-key example. The names and variable substitutions are the changes; the Secret keys follow the documented format.

The example reads key contents from a file instead of putting the private key in a shell argument or Helm values. The file, Kubernetes Secret, Secret-reading permissions, and key rotation remain security responsibilities. See ARC authentication and runner-group access controls.

If an approved personal access token is used instead, the Secret uses the documented github_token key and the permissions required for the chosen registration scope. That is an alternative authentication configuration, not an additional credential required alongside the GitHub App.

This credential authenticates ARC to GitHub. It does not authorize an Azure deployment. Deployment jobs need a separate, least-privilege identity relationship, such as GitHub-to-Azure OIDC, rather than general access through the installer, cluster, or kubelet identity.

Step 8: ARC controller and runner scale-set configuration

The examples use released OCI charts rather than legacy RunnerDeployment resources or experimental charts. Both ARC charts are pinned to release 0.15.1; version selection remains subject to review against the official release.

Figure 3. ARC autoscaling runner scale sets.

Controller configuration

These Helm values select the system pool and an explicit controller service-account name. They adapt fields from the release-specific controller chart values. The names, pool selector, and resource sizes are design-specific values, not the chart defaults or measured sizing recommendations. The values correspond to the controller configuration input referenced by --values in the example command.

fullnameOverride: arc-controller
serviceAccount:
  name: arc-controller
nodeSelector:
  kubernetes.azure.com/agentpool: systempool
resources:
  requests:
    cpu: 100m
    memory: 128Mi
  limits:
    memory: 256Mi

The installation command adapts the official controller Helm installation, adding the documented version and values-file options. The wait and timeout settings are operational choices, not ARC requirements.

export ARC_CHART_VERSION="0.15.1"

helm install arc \
  --namespace arc-systems \
  --create-namespace \
  --version "$ARC_CHART_VERSION" \
  --values ./controller-values.yaml \
  --wait --timeout 10m \
  oci://ghcr.io/actions/actions-runner-controller-charts/gha-runner-scale-set-controller

kubectl get deployments,pods --namespace arc-systems

Step 9: Workflow targeting the private runner

The workflow follows the official ARC quickstart's verification workflow, with a descriptive name, the example scale-set target, and an English output message. It uses workflow_dispatch and a runs-on value matching runnerScaleSetName. The empty permission set and five-minute job timeout are additional restrictions for this shell-only example, not ARC prerequisites.

Manual dispatch requires the workflow to be available on the repository's default branch. See GitHub's manual workflow requirements.

name: Private AKS runner verification

on:
  workflow_dispatch:

permissions: {}

jobs:
  verify-runner:
    runs-on: arc-private-aks
    timeout-minutes: 5
    steps:
      - run: echo "This job uses runner scale set runners."

The expected lifecycle includes a queued job, an ephemeral runner pod placed on the runners pool, workflow output, and automatic removal of the runner after completion. A pool that has scaled to zero adds node-provisioning time before the runner can start.

This workflow verifies job execution only. It intentionally uses no checkout action, cloud login, package feed, artifact upload, or deployment target, and does not actively probe a separate Internet destination. It does not establish complete build-pipeline readiness or prove the firewall route. Those dependencies require separate evidence. See using ARC in a workflow.

Documented limitations and design boundaries

AreaLimitation and consequenceOfficial reference
Network-isolated AKSRequires Kubernetes 1.30 or later and the documented CLI minimum. A currently supported regional release is still required.Creation prerequisites
Outbound modenone is GA and does not configure or block egress. block is preview and restricted to managed-VNet scenarios.Outbound types
Nodes and networkingNetwork isolation does not support Windows pools or kubenet. The documented node-OS upgrade channels are NodeImage and None.Network-isolation limits
Bootstrap registryThe AKS cache does not make arbitrary application images or workflows offline-capable. BYO ACR adds Premium/private-DNS work.Network-isolated AKS
Add-ons and explicit egressOptional features can require additional endpoints. Node public IPs can permit outbound traffic and are not enabled here.Feature limitations
Virtual WAN default routeThe default route is not propagated between hubs. This baseline uses local inspected Internet breakout.Routing intent
Routing-intent compatibilityCustom hub route tables and specified static next-hop-VNet-connection routes have restrictions.Routing prerequisites
Same-VNet trafficRouting intent does not automatically attract traffic between subnets of the same VNet. Private API access here stays local.Hub routing considerations
Firewall inspectionStandard HTTPS filtering uses SNI, not decrypted payloads or full URL paths. Premium inspection needs certificate trust.Firewall SKUs
Network-rule FQDNsRequire DNS proxy. Wildcard support is currently limited to the regions listed in the product documentation. This design uses application rules for GitHub HTTPS.FQDN filtering
Secured-hub SNAT designNAT Gateway integration inside a secured virtual hub is unsupported. Conventional firewall-subnet NAT patterns do not apply.NAT Gateway integration
GitHub authentication scopeGitHub App authentication is not supported for enterprise-level runner registration. That scope needs a different setup.ARC authentication
Container-based jobsThis shell-only configuration does not support Docker-dependent jobs as configured. Documented DinD needs privileged mode.ARC container modes
Workload isolationEphemeral runners, namespaces, and node pools are not a sandbox for hostile code.GitHub secure use, AKS isolation
Support and customizationGitHub ARC support does not certify the underlying Azure network or every custom pod template, hook, or storage integration.ARC support boundaries
Updated Nov 18, 2026
Version 1.0

1 Comment

  • Arshrao's avatar
    Arshrao
    Copper Contributor

    Great architectural breakdown! Using a network-isolated AKS cluster with outbound type none, a secured Azure Virtual WAN hub, and GitHub Actions Runner Controller (ARC) provides a very solid security boundary. whenever outbound runner calls or authentication endpoints hit unexpected timeouts in setups like this, I always check https://isitdownjustmeorforeveryone.com/  (you can also check if GitHub is down for everyone or just me there) just to rule out broader cloud or API service hiccups before diving into firewall logs. Thanks for sharing!"