What does HackerNews think of nebula?

A scalable overlay networking tool with a focus on performance, simplicity and security

Language: Go

Interesting. I thought recognized the logo, apparently seems to be a commercial support offering of https://github.com/slackhq/nebula and they support the "nebula" iOS app. I had been using for nebula/defined in the past.
Part of what you're paying for with the AWS instance is "easy", documented integration with the rest of the AWS ecosystem, including things like access control and monitoring.

If you already know how to run the desired workloads on the laptops, then most of what remains is a way to make it accessible to the rest of your infrastructure. Cloudflared, nebula, or wireguard tunnels are a few options.

I use nebula (https://github.com/slackhq/nebula) to network all the machines of my homelab, regardless of how they're connected to the internet, including my laptops. I do think there's space for more lightweight and batteries-included options to take advantage of connected resources in this model.

I used and still really adore tinc, it's been a joy to use.

I will say however that development appears to have fizzled out. I was really looking forward to some of the changes in 1.1, but it's been in pre-release for years now and doesn't seem like it's closer to being officially released.

I've largely replaced tinc with Nebula [0], but I still think fondly of it.

[0] https://github.com/slackhq/nebula

Slack's Nebula is another great open source mesh VPN application: https://github.com/slackhq/nebula
There's another dead comment saying the same thing, but take a look at Nebula. I set it up over a year ago and haven't really thought about it much since - it just works. The open source version doesn't have any fancy GUIs or anything but it's not very hard to deploy. Covers every OS that you'd probably care about too.

https://github.com/slackhq/nebula

You should give nebula a try. I've recently switched my private VPN setup from wireguard to nebula and am looking into using it for work. It has some really nice features (for our use case), so ymmv. But so far it's been fantastic and very easy to use.

https://github.com/slackhq/nebula

link for the lazy: https://github.com/slackhq/nebula

Also with no ill intent looks like tailscale has the far more effective marketing organization :)

Very cool concept.

Reminds me of the intended use case of Nebula, which seems very similar to this. If you're interested in a bare-bones and totally self-hosted option, it could be a good choice here. https://github.com/slackhq/nebula

nebula[0] may be interesting; you can allow list connectivity for specific groups, all burned into the cert used to join the network. It uses some NAT hole punching orchestration to accomplish connectivity between hosts without opening ports.

The main painful thing I've found has been cert management. PKI, as usual, is not a solved problem.

I've managed to do some fun stuff using salt + nebula on the hobby side.

[0] https://github.com/slackhq/nebula

>I've been meaning to look into this with wireguard, but I'm having trouble searching for/finding how to do this. Is "bastion host" what I'd want? Also is there a way to ensure the VPS cannot access the network as well, and just tunnels it essentially?

First, yes a search phrase like that should get you the right terms, though there isn't anything inherently special about it. If multiple systems are connected to one system with wireguard giving them all access to a given subnet is straight forward. As far as the VPS, it can indeed access that subnet too, since it's acting as part of the subnet, but you can use normal firewall rules on the far side internally to control what can talk to what and how. And in this kind of specific instance the WG is more about controller public facing surface area, the Bitwarden/Vaultwarden traffic in flight is itself encrypted.

Second though, having said all that I think if you worried about the VPS bit (or even if not) you should take a look at the Nebula SDN [0, 1] instead. It's built on the Noise encryption framework as well. There, the fixed IP node (the "Lighthouse") primarily acts to let other nodes know their mutual addresses, and they then attempt to form a direct link with no bouncing through a bastion, it's a real mesh. This generally works even if both are NAT'd, and if not it's transparent fallback and still encrypted between them. Depending on distance between nodes this can be a lot lower latency as well. With Nebula you establish an internal CA (super easy built-in tool for it) and that doesn't (and absolutely shouldn't) live on the lighthouse.

I'm fortunate enough to have fixed IPs available to me at home and office and have tended to use WG a lot just because it's had more advanced support and performance in constrained environments for me (kernel support in Linux and now BSDs). Nebula has been super slick though and I've been using it more and more. It makes all this really easy.

Anyway, hope this helps a bit. It's really exciting to me how much open source networking power is now available to everyone. It's a bit of a counter decentralization force IMO to the last few decades push towards central service providers.

----

0: https://github.com/slackhq/nebula

1: https://arstechnica.com/gadgets/2019/12/how-to-set-up-your-o... (note 3 years old, there are now Android/iOS clients as well and things are further refined)

This is very nice and looks like a useful tool.

It's also very much not a "Tailscale Alternative" – it explicitly describes itself as not being "a tool for creating mesh networks", which is the exact thing that Tailscale is all about.

Nebula (https://github.com/slackhq/nebula) is much closer to actually being a fully open-source and self-hostable Tailscale alternative as I understand it, though I've never used it myself.

Indeed, this is why I won't use it either. I settled on Slack's Nebula [0] instead of wireguard because it handles direct p2p communication between nodes automatically.

There also exists an open source implementation of the tailscale control server [1] that you could self host.

[0] https://github.com/slackhq/nebula

[1] https://github.com/juanfont/headscale

Nebula is probably a better choice for something a little longer term -- bandwidth isn't funneled through one VPN gateway.

Once the clients talk to the lighthouse to build the tunnel they communicate directly

https://github.com/slackhq/nebula

If you don't want your technology to have a proprietary stack, then definitely checkout Nebula[1]. It's very easy to setup and works very well in my experience.

[1]: https://github.com/slackhq/nebula

ZeroTier and Nebula are the only modern alternatives I personally know about.

https://www.zerotier.com

https://github.com/slackhq/nebula

Disclosure: I wrote and founded ZeroTier. Listed Nebula too for neutrality and completeness.

Just deploy https://github.com/slackhq/nebula somewhere and voila - you have your own completely self-hosted version of Tailscale.
Thanks :) We are using Nebula[1] to provide an encrypted private meshed network per project, so each project have it's own network range. We have automated that with a rest api and have published it as an open source project[2]

It's really cool because you have out of the box a private network across all cloud providers and also works for on-premise deployments

[1] https://github.com/slackhq/nebula

[2] https://github.com/elestio/nebula-rest-api

No one uses Nebula [1] developed by Slack?

> Nebula is a mutually authenticated peer-to-peer software defined network based on the Noise Protocol Framework.

It's self-hosted and I think it's a great alternative to ZeroTier, or Tailscale.

I believe its been powering Slack's overlay network for ~5+ years.

[1]: https://github.com/slackhq/nebula

I've been looking through the available options for this use-case, with the same motivation given in this post, and was surprised to see there wasn't something which could fit this niche (until now!).

Really happy to see this being worked on by a dedicated team. Combined with a tool like https://github.com/slackhq/nebula this could help form the foundation of a fully autonomous, durable, online community.

Have you taken a look at Nebula [0]? Might fit your needs. It also uses the Noise Protocol Framework but adds the bells and whistles on top needed to synthesize an overlay network like you want. MIT licensed too fwiw, full self hosting. Worth a look at any rate, WireGuard is much lower level though I'm sure it could be built upon for the same purpose.

----

0: https://github.com/slackhq/nebula

Have you looked into https://github.com/slackhq/nebula? It uses X509 cert for auth.

Although for my home lab, using X509 is more of a minus than a plus due to complexity involved.

As other have suggested, Nebula (https://github.com/slackhq/nebula) is pretty elegant. It has groups-based access built in which is extremely convenient.

You can bolt-on SSO fairly easily - just create a certificate signing service. I created https://github.com/unreality/nebula-mesh-admin in a weekend, so its fairly easy to add a SSO flow in.