errgroup | errgroup with goroutine worker limits

You'll need to do more than just mount the certs directory; Buildkit does not pick them up. To specify custom certificates for a registry, The documentation you linked details how you can use a custom self-signed certificate with a singular Docker Registry, and not in this more general case across a whole build. You can use these docs if you need to push or pull from a registry with custom certificates. Do not forget the additional configuration in buildkit_additional_config if this needs to be configured in your situation.

Now, on to why +hello-world is failing. The GIT CLONE command uses git under the hood. While git on your local machine may be configured to use these custom certificates, the git inside the build here is different, and does not share the same certificate configuration. You'll need to bring in the certificates manually via a COPY, or using a --secret/--secret-file/--build-arg to make it accessible, depending on your use case.

We have some examples in our unit tests that cover this use case. Here is using one with a custom clone over HTTPS using a custom cert; and here is how we are adding a custom cert to a build.

TLDR: I guess I had containers in the background that were binding ports.

Simple fix:

In this version of the code, the execution is blocked until ch is closed.

ch is always closed at the end of a routine that is responsible to push into ch. Because the program pushes to ch in a routine, it is not needed to use a buffered channel.

Looking at your code, two things can cause a deadlock:

• errg.Wait() blocks the execution of the main goroutine until all initialized goroutines are finished. However, each goroutine is blocked when trying to write to mapChan, because you never get to read from it (because it is below the errg.Wait()).
• You never read from sliceChan, so that is a potential deadlock right there.

Here is the link to the modified Playground code, but most of the changes are in the main function.

Pass the context to the fetch function and exit on cancel:

Assuming you're using http.ListenAndServe and golang.org/x/sync/errgroup:

• An errgroup's Wait returns when all functions have returned.
• The errgroup's Go call calls the given function, and if the function returns an error, calls the cancel function in the context of the group. If you have not called WithContext to create a group that has a context, though, you have a group that has no context, so no cancel() happens.

Your eg.Wait() call waits for both ListenAndServe calls to return. If you had a cancellation function and used that to stop other ListenAndServe invocations, that would help. See How to stop http.ListenAndServe(). But you'll also need a WithContext so that you have a way to know when to stop the other ListenAndServe calls. Note that you will want to stop all others, not just the (singular) other, once you have more than two such.

One way to keep track of errors is to use a status struct to keep track of which error came from where:

Answer as proposed by @mkopriva.