Golang cli application - how to use context properly?

I'm new to golang and somewhat confused about context and how to use the context in golang applications.
Specifically im working on the cli application and just need to access mongo, for example.

Like - is this correct that I just create single shared ctx context variable, then use it for any operations that need context?

Would any operation that needs context restart the 5-second timer? or is this a shared timer?

package main

import (
	"context"
	"log"
	"os"
	"time"

	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"go.mongodb.org/mongo-driver/mongo/readpref"
)

func main() {

	log.SetOutput(os.Stdout)

	// Create a context with a timeout of 5 seconds
	//This defines a timeout context that will be canceled after 5 seconds.
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	// always defer in case func returns early
	defer cancel()

	//Creates a new ClientOptions instance.
	clientOptions := options.Client()
	clientOptions = clientOptions.ApplyURI("mongodb+srv://127.0.0.1?retryWrites=true&w=majority")

	//Connect to mongo
	client, err := mongo.Connect(ctx, clientOptions)
	defer client.Disconnect(ctx)
	if err != nil {
		log.Fatal(err)
	}

	//Test connection to the database
	log.Println("I: test mongo connection using ping")
	err = client.Ping(ctx, readpref.Primary())
	if err != nil {
		log.Fatal(err)
	}

	log.Println("I: Fin")
}

You create a new context variable for each operations that need context.
The timer of a context will never restart.

In your example, try to add time.Sleep(6*time.Second) after context.WithTimeout, you will see all operations return error context deadline exceeded.

If you think about it, it makes no sense that a context.Context could be shared "horizontally" (meaning between operations not part of the same call stack). A golang Context provides the context within which an operation (including any nested operations below it in the call stack) are to be performed - such as "within X seconds," to protect against hanging due to communications delays, etc. So if you issue 10 requests in parallel, you should give each one its own context - you probably don't want the tenth one to fail because the first one did. If you are just using a context.Background() or context.TODO(), without further decoration, you probably don't need to store the Context in a variable the first time you create it - you can just create when you pass it to the first function in the call stack, and properly constructed code will pass it down the stack as appropriate, applying necessary decorations along the way:

func Execute() {
DoThing(context.Background())
// Other stuff
}
func DoThing(pctx context.Context) {
ctx, cancel := context.WithTimeout(pctx, 10 * time.Second) // Timeout after 10 seconds
defer cancel()
DoThingThatMayTakeAWhile(ctx)
select {
// You may want other stuff here
case <-ctx.Done():
// Context timed out, maybe log an error?
}
}
func DoThingThatMayTakeAWhile(pctx context.Context) {
DoThingNeedingInfoInContext(context.WithValue(pctx, "thisisakey", "value"))
}
func DoThingNeedingInfoInContext(ctx context.Context) {
val := ctx.Value("thisisakey")
// Do something with val, check that it isn't nil, etc.
}

If I were to make multiple calls to DoThingThatMayTakeAWhile(), I'd want to give each one a separate child context - I would not want to share ctx with each of them.

So in your code, every call to mongo.Connect() should receive a freshly created context.Context instance.