An access control list (ACL) is a set of rules that decides which identities are allowed to reach which resources, and on which ports. On a private mesh network like a tailnet it is where you scope access: instead of a node being reachable on everything, an ACL restricts each identity to exactly the services it should see, and blocks the rest by default.
At a glance
What it is
Rules mapping identities to the resources and ports they may reach
Default posture
Deny by default; rules open only what is named
Where it lives here
The policy file of a tailnet, scoping each node and identity
Why it matters
It is how a shared node exposes one service, not the whole machine
Flow
How an ACL scopes a shared node
A request carries an identity. The ACL checks it against the rules and allows only the named service. Everything not explicitly allowed is denied, which is the safe default.
1
A request arrives with an identitywho is asking, from which tailnet
2
The ACL checks identity against the rulesis this identity allowed this port?
3
Allow the one named service, deny the restthe rest of the machine stays invisible
What is an ACL?
An access control list (ACL) is just a list of rules that say who may reach
what. Each rule pairs an identity, a person or a machine, with the resources and
ports it is allowed to touch. The important half is what the rules do not say:
anything not explicitly allowed is denied. On a private mesh network such as a
tailnet, the ACL is the policy file where you decide that one identity can reach
the inference port and nothing else, while the rest of the machine stays
invisible to it.
Why does the ACL carry so much weight?
Because by default a shared node is reachable on every port, which is almost
never what you want. The ACL is the difference between sharing one service and
handing over the whole machine. The right pattern is to scope a share to exactly
the service the other side needs: the inference endpoint, say, and not the
dashboard, the secure shell, or anything else listening. And an ACL is only as
good as its test. Run a port scan from the restricted side and confirm that the
one intended port is open and the rest are filtered. A rule you assumed was
tight, but never checked, is the kind that quietly leaks.
Check it yourself
nmap -p- <shared-node-tailnet-ip>
From a restricted identity, a correct ACL leaves only the one allowed port open and every other port filtered. If a port you did not intend to share shows up, the ACL is too loose.
A good ACL does
Scope a shared node to exactly the one service it should expose
Deny by default, so a forgotten port stays closed
Name identities explicitly, so access is auditable
Get tested with a port scan, not assumed correct
Do not
Leave a shared node wide open on all ports
Add a friend's machine into your own network instead of scoping a share
Allow broad ranges when one port would do
Trust the rule without verifying it from the restricted side