Your CI went multicloud. Your firewall did not get the memo

The most reassuring sentence in an incident call is also one of the least useful.

“Nothing changed.”

In our fictional deployment team, someone has checked the commit. Someone else has compared the workflow files. A third person is inspecting credentials with the concentration usually reserved for unexploded ammunition. Yesterday, this pipeline published a container image to a protected registry. Today, the connection times out.

The code is identical. The credentials are valid. The YAML has the spotless record of a suspect who was demonstrably elsewhere.

Someone clicks Re-run jobs, the small rectangular prayer button of modern infrastructure.

What nobody has checked yet is where the runner lives.

The team bought managed compute partly to avoid caring about that detail. Unfortunately, their firewall cares deeply. It has an approved list.

The infrastructure moved without touching your YAML

On October 28, 2026, GitHub announced that eligible hosted Linux jobs could execute on AWS alongside Azure. Workflow syntax and runner labels remain unchanged.

The expansion covers standard 2-core and 4-core Linux runners and compatible larger runners. Eligible workloads on Free, Pro, and Team adopt it automatically. Enterprise Cloud customers can opt in. Windows runners and specialized configurations, including private networking, are excluded. The stated goals are additional capacity, shorter capacity-related queues, and improved resilience. 

From the workflow author’s perspective, this is pleasantly uneventful. The job still asks for a runner. A runner appears. Nobody has to attend a migration workshop.

Elsewhere, however, a network policy may contain a list of Azure source ranges copied into place when the integration was first approved.

Your workflow described the job. Your firewall had quietly become documentation for where the job was supposed to live.

These two documents have now developed a difference of opinion.

The firewall is enforcing an old assumption

Back at our fictional registry, the access rule permits traffic from selected Azure ranges. A runner whose outbound address falls outside that list cannot establish the connection. Its perfectly respectable credentials never get an opportunity to introduce themselves.

Depending on where access is enforced, the symptom might be a timeout, an explicit rejection, or an authentication policy denial. Those deserve different investigations, although all three can initially arrive in the incident channel as “deployment broken.”

GitHub explicitly warns that allowlists limited to Azure or Microsoft-owned ranges, including relevant Entra Conditional Access policies, can block the expanded runner pool. 

The intended policy was to admit the company’s deployment workload. The implemented policy admitted traffic from particular networks. The distinction remained comfortably invisible while both happened to produce the same result.

The firewall was doing its job perfectly. Unfortunately, its job description had expired.

This is an architectural dependency hiding inside a security control. The deployment depended on the workflow interface, but also on an assumption about the provider’s infrastructure placement.

That assumption probably never appeared in the architecture diagram. There was already a cloud-shaped icon, and everyone felt the matter had been addressed.

Before rotating another credential, check whether the failed run came from a different network. If your organization permits this external lookup, a temporary diagnostic step can record the runner’s public egress address.

- name: Record runner egress IP
  run: curl --fail --silent --show-error --max-time 10 https://api.ipify.org

Compare the result with a successful run and the destination’s access logs. This shows the public address observed by the lookup service. A proxy, VPN or destination-specific route may cause the registry to see a different address, so its logs remain the stronger evidence.

A source address cannot introduce your workflow

A registry receives a connection from an approved IP range. What has it learned?

Something about the connection’s origin. It has not established that the caller belongs to your repository, passed your tests or has permission to publish your production image.

There are three separate checks here.

Connectivity determines whether the runner can reach the service. Authentication establishes the caller’s identity. Authorization determines what that identity may do.

Network restrictions remain useful, but they cannot carry the entire burden of identifying a workload.

GitHub’s OIDC integration provides a more specific basis for cloud authentication. A workflow obtains an identity token containing claims. A cloud provider checks those claims against a configured trust policy and, when they match, issues short-lived credentials. This reduces the need to store long-lived cloud credentials in repository secrets. 

The important engineering work is in that trust policy and the permissions attached to it. A narrowly scoped identity should receive narrowly scoped access. Making credentials temporary does not make excessive permissions modest.

Nor does OIDC repair connectivity. A valid passport does not help much when the road to the border is closed.

You can have impeccable authentication and an unreachable endpoint. You can also have excellent connectivity and a caller who should never have been allowed near the registry. A functioning deployment needs all three checks to agree.

Faster runners can fail more efficiently

Our job now starts promptly. It reaches the registry step, waits for a connection, and eventually gives up.

A runner that starts immediately and cannot reach its dependencies is a very efficient way to fail.

This illustrates a limit of improving one component in a longer operational path. Compute capacity matters, but so do artifact storage, identity services, deployment endpoints, and the policies between them.

The architectural implication is that provider-side improvements can expose consumer-side assumptions. This is not evidence of a widespread outage caused by GitHub’s rollout. It is a reason to test the whole integration.

It also puts the word multicloud in its proper-sized box.

Executing jobs across two providers does not establish complete disaster recovery. Shared scheduling, repository access or identity dependencies may still affect the entire process. Two places to run a job are useful. They do not prove that everything required to run it has become independent.

The architecture diagram gets a second cloud icon. The recovery plan still needs an actual rehearsal.

Choose the network contract your deployment needs

The immediate temptation is to add more ranges until the pipeline turns green. That may restore service. It should also prompt a decision about what the deployment requires.

Variable public egress can be acceptable. GitHub publishes runner ranges in the “actions” array of its Meta API and recommends synchronizing applicable allowlists with that source. Treat synchronization as an owned process, with change visibility and failure handling. Keep authentication and authorization independent of those network ranges.

Predictable egress may be a requirement. Where destination policies demand a constrained origin, evaluate a runner arrangement with controlled outbound networking. Consider connectivity, availability, cost, and the person who will receive the alert when it stops working. “We control it” is the beginning of an operating model, not the end of a risk assessment.

Building and deploying can have different requirements. Compilation and testing may suit flexible hosted compute, while production deployment runs in a more restricted environment. If you separate them, preserve the identity and integrity of the artifact between stages. Deploy the verified artifact by an immutable identifier rather than rebuilding something approximately similar and trusting the family resemblance.

Self-hosting is one possible choice, with patching, isolation, cleanup, and credential handling attached. Moving a runner into your network also moves its operational problems onto your calendar.

The useful question is what each stage needs from its network environment, and who maintains that agreement when either side changes.

Audit one pipeline before the next surprise

Choose one production pipeline. Follow its connections beyond the tidy sequence of steps displayed in the interface.

Write down the endpoints it contacts. Identify which controls depend on source addresses and which verify workload identity. Find the owner of each policy. Check whether the available logs can distinguish a dropped connection from a rejected token or insufficient permission.

Then ask what would happen if the job originated from a different network.

That is a small investigation with a potentially awkward result. You may discover that an important deployment depends on an IP list whose last known custodian left the company carrying a farewell mug.

Give that dependency an owner, a maintenance process, and a test.

The YAML in our opening scene was innocent. It simply did not describe everything the deployment needed to succeed.

Your next deployment failure may arrive without a single changed line in Git. Check which parts of your architecture still treat that as impossible.

Share