ncc VS telepresence

During my search for deploying Lambdas via GitHub actions, I came across a tutorial that utilized ncc for converting TypeScript and bundling. While ncc is effective, I discovered esbuild, which proved to be significantly faster and perfectly suited to my requirements.

You could use ncc to compile a binary:

https://github.com/vercel/ncc

This appears to be caused by lazy loading of image layer data, particularly during container initialization, and latency introduced by the read operations. In general, you want to access as few files and as little data as possible during the initialization of your functions. For example, we've seen improvement when using ncc to bundle Node.js applications.

What we do however, is bundle all these dependencies, and our own code into a single JS file using the nifty ncc tool (thanks Vercel!)

Vercel's ncc compiler

The most unclear and confusing part is packing the code using ncc. The necessity of this step is caused by GitHub’s approach to running your Action.

I filed an issue for the ncc bundler regarding a similar behavior

This may be slightly tangential but I recently discovered ncc[1] from vercel which can take a single node project and compile it and all dependencies to a single file.

As an added benefit it also collapses all contained dependencies license files into a single licenses.txt file too!

- [1] https://github.com/vercel/ncc

The current process of building a package locally is by running through a gulp task, using ttypescript to compile the TS and @vercel/ncc to build the binary:

I trialled Telepresence[0] for my company 2 or 3 years ago, that does this sort of thing very slickly. It didn't quite work for us back then, I forget why, but I imagine it's come along a way since then.

[0] https://www.telepresence.io

How does this compare to Telepresence?

seems to be very similar to https://www.telepresence.io

If they're web services you work on, you might try https://www.telepresence.io/ (Requires something to be installed in the cluster though, easily done).

Depending on the context, the type of code you do, you may want to also look into the sister protocol to LSP, DAP—debug adaptor protocol. It really depends on your context whether local dev, dev against a remote server, and if the latter whether you run under GCP and thus have the “Snapshot Debugger”, or under Kubernetes with something like Ambassadar/Emissary and thus can run Telepresence, whether you do local or remote Docker and thus most IDEs don't necessarily magically work especially if the containers are competently locked down, etc.

If you're on Kubernetes remotely, Telepresence [0] might be worth a look.

[0] https://www.telepresence.io

Sounds Like Telepresence (https://github.com/telepresenceio/telepresence) which intercepts traffic to a service on the cluster and directs it to your local environment.

This seems to be very similar to Telepresence, which I just couldn't get to work for us.

What the difference with okteto and telepresence ?