# Map your egress before the client's IT asks why you need port 80

> Take the host list from each vendor, request domains rather than IP addresses, and explain every line before the firewall ticket goes out.

Original: https://fdetimes.net/en/guides/egress-map-firewall-allowlist/

Snowflake's list of hosts that customers should add to their firewall includes port 80. That port carries plain HTTP for checking whether a certificate has been revoked (OCSP). If your allowlist request says only "443 out to the internet", the connection can still break in exactly the place few people look.

Inside a client's company, the network is usually what holds a deployment up longest. The code runs and the data is ready, but everything stops to wait for a firewall ticket. Each time IT sends the ticket back with a question, you lose a few more days.

This guide shows how to build an egress map clear enough for IT to approve on the first pass. It follows one hypothetical client from start to finish.

The client is a logistics company. Your solution reads data from Snowflake and runs CI on a self-hosted runner for GitHub Enterprise Server, and your team uses Claude Code inside the client's network.

To follow along, you need permission to run queries on the Snowflake account (if the solution uses one), the network documentation for each vendor, and to know which cloud and region the client runs on.

## Step 1: list components before listing domains

Start by listing every component of the solution that will call out of the network. In this example there are three: Snowflake, the CI runner and Claude Code. For each one, record the cloud, the region and the connectivity mode, because those three facts decide which endpoints actually need to be open.

Databricks is not part of the scenario, but its documentation is the clearest illustration of the point. The endpoints to open change with region and deployment mode; with PrivateLink, for instance, there is a separate SCC relay endpoint. A list copied from a project in another region can therefore be entirely wrong.

**Check:** every component has all three columns filled in: cloud, region and connectivity mode. If any cell is empty, ask the client before going further.

## Step 2: take the list from the source, don't guess

Snowflake provides a function that returns exactly the hosts and ports to add to a firewall allowlist. Run it on the client's own account:

```sql
SELECT SYSTEM$ALLOWLIST();
```

The function returns a JSON array in which each element has three key/value pairs: the type (`type`), the host and the port. The snippet below only illustrates the shape of the result. Values in angle brackets are placeholders, not real hosts:

```json
[
  {"type": "<TYPE>", "host": "<host-1>", "port": 443},
  {"type": "OCSP_RESPONDER", "host": "<host-2>", "port": 80},
  {"type": "STAGE", "host": "<host-3>", "port": 443}
]
```

Two things matter here. The port is not always 443: the documentation states plainly that port 80 is included too. And some types, such as `STAGE` and `OCSP_RESPONDER`, can return several rows, so the map has to be built from the full output rather than from a single hostname.

Back to the logistics client. Say the output has 6 elements: 1 account host, 2 `STAGE` rows and 3 `OCSP_RESPONDER` rows on port 80. A ticket that says only "443 out to the internet" covers 3 of the 6 rows and misses the entire certificate check.

**Check:** the number of Snowflake rows in your table equals the number of elements in the output, 6 in this example. Every port 80 row carries a note that it is used for certificate checks.

## Step 3: why should IT allow domains rather than IPs?

Many IT teams prefer IP-based rules because they feel easier to control. Propose the opposite, and bring the reasoning with you. Databricks advises customers to always allowlist SCC relay endpoints by domain (FQDN).

Databricks also warns that the IP addresses behind these domains change periodically. Customers who pin specific IPs can suffer service disruption whenever the infrastructure changes.

Put that argument into the ticket word for word. Otherwise you are setting up an incident a few months out, and the person woken in the middle of the night is often you.

## Step 4: spell out CNAMEs and wildcards

GitHub notes that some of the domains a self-hosted runner needs are configured as CNAME records. This matters for firewalls that build rules by resolving DNS, because the final destination domain may also have to be allowed. Add a note on the runner's line so IT can check it on their own equipment.

Wildcards must be written exactly. Claude Code's documentation requires allowing `*.claudemcpcontent.com` with the asterisk kept intact. If this host is blocked, the rest of the application still runs but widgets fail to load.

A half-broken failure like that is very hard to diagnose, so write the consequence of blocking into the purpose column, and request this line only if the team actually uses widgets.

## Step 5: trim before you send

The shorter the list, the faster IT approves it. Some vendors already mark which hosts are optional. According to Claude Code's documentation, two Datadog intake hosts carry only optional operational telemetry, and setting the `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` variable turns both off:

```bash
# A value of 1 is the usual way to set the flag; check the documentation for your version
export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1
```

In the example, you set this flag first and only then delete the two Datadog rows from the table. The ticket loses two lines, and IT can see you are asking only for what you need.

## Step 6: proxies and TLS inspection belong on the map

In many enterprises, outbound traffic must go through a proxy and may be TLS-decrypted for inspection. Claude Code uses the standard proxy environment variables and the operating system's certificate store. The map therefore needs a section recording the proxy address and how the client installs certificates:

```bash
# Standard proxy variable; the address is an illustrative placeholder
export HTTPS_PROXY=http://<customer-proxy>:<port>
```

Ask IT at the outset whether they decrypt TLS. If they do, state clearly that their root certificate must be in the certificate store of the machine running the solution.

## Step 7: what does a finished ticket look like?

Claude Code's network documentation page is a model worth copying: a table of URLs, each with its purpose. Your request should take the same form, with added columns for connection direction and whether each line is required. Below is the table filled in for the example. Hostnames are in angle brackets because they must come from the client's real environment:

| Host (FQDN) | Port | Direction | Purpose | Required? |
|---|---|---|---|---|
| `` from SYSTEM$ALLOWLIST | 443 | Outbound | Querying data in Snowflake | Yes |
| ``, `` (type STAGE) | 443 | Outbound | Reading and writing data through stages | Yes, both rows |
| `` to `` (OCSP_RESPONDER) | 80 | Outbound | Certificate revocation checks | Yes, all 3 rows |
| GitHub Enterprise Server domains for the runner | Per GitHub documentation | Outbound | Runner picks up CI jobs; some domains are CNAMEs | Yes |
| `*.claudemcpcontent.com` | Per documentation | Outbound | Loading widgets; if blocked, the rest still runs but widgets don't appear | Only if the team uses widgets; if requested, keep the wildcard |
| 2 Datadog intake hosts | — | — | Optional telemetry | Not requested: disabled by flag |

The top of the table states the cloud, region and proxy address. At the bottom, add one sentence making clear that no inbound access is needed. For self-hosted runners, GitHub states that only connections from the runner out to GitHub Enterprise Server are required, with none in the other direction. Not having to open any inbound port is the strongest argument you can give the client's security team.

**Check:** every line has a purpose, no line lists an IP address, and every excluded line states why it was dropped.

## Mistakes that get tickets sent back

The most common is writing "443 out to the internet" and forgetting port 80 for OCSP. Next comes sending a list of IPs from a single DNS lookup, so the connection breaks when the vendor's infrastructure changes addresses. Third is copying an endpoint table from a region or connectivity mode that differs from the client's environment.

Two smaller mistakes cost just as much effort. One is writing a wildcard as a single specific host. The other is asking to open telemetry hosts when one environment variable would switch them off.

## Bringing the skill into projects and your CV

At the client kick-off, ask to meet the person responsible for the network in the first week instead of waiting until the code is ready. Bring the table above, with region and connectivity mode already filled in.

On a CV or in an interview, avoid the vague "worked with the client's IT". Describe a specific ticket: which source you took the list from, which hosts you dropped, and why the ticket was approved on the first pass.

When a job posting mentions restricted networks, corporate proxies or on-prem deployment, that is the moment to tell this story. In those environments there is almost certainly a firewall ticket waiting for someone to write it.

A well-written firewall ticket goes unnoticed: it gets approved and that is the end of it. A rushed one can leave a whole project waiting.

**Try this week:**

- Run SELECT SYSTEM$ALLOWLIST(); on a test Snowflake account and count how many OCSP_RESPONDER rows and how many STAGE rows the output contains.
- Pick a project you are working on and write an egress table with columns for host, port, direction, purpose, and required or optional. Add the cloud, region and connectivity mode at the top.
- Open the network configuration page of a tool you use, mark the optional hosts and find the flag that turns them off.

## Sources

- [SYSTEM$ALLOWLIST | Snowflake Documentation](https://docs.snowflake.com/en/sql-reference/functions/system_allowlist)

- [IP addresses and domains for Databricks services and assets | Databricks on AWS](https://docs.databricks.com/aws/en/resources/ip-domain-region)

- [Communicating with self-hosted runners - GitHub Enterprise Server 3.13 Docs](https://docs.github.com/en/enterprise-server@3.13/actions/concepts/runners/communicating-with-self-hosted-runners)

- [Enterprise network configuration - Claude Code Docs](https://code.claude.com/docs/en/network-config)
