diff --git a/.golangci.yml b/.golangci.yml
index f38b7e066f..f694dc87f7 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -15,6 +15,7 @@ linters:
     - govet
     - misspell
     - nakedret
+    - noctx
     - nolintlint
     - perfsprint
     - revive
diff --git a/docker_auth_test.go b/docker_auth_test.go
index 74042fc573..31ac362c86 100644
--- a/docker_auth_test.go
+++ b/docker_auth_test.go
@@ -198,7 +198,7 @@ func TestBuildContainerFromDockerfileWithDockerAuthConfig(t *testing.T) {
 	// using the same credentials as in the Docker Registry
 	setAuthConfig(t, registryHost, "testuser", "testpassword")
 
-	ctx := context.Background()
+	ctx := t.Context()
 
 	redisC, err := Run(ctx, "",
 		WithDockerfile(FromDockerfile{
@@ -223,7 +223,7 @@ func TestBuildContainerFromDockerfileShouldFailWithWrongDockerAuthConfig(t *test
 	// using different credentials than in the Docker Registry
 	setAuthConfig(t, registryHost, "foo", "bar")
 
-	ctx := context.Background()
+	ctx := t.Context()
 
 	redisC, err := Run(ctx, "",
 		WithDockerfile(FromDockerfile{
@@ -247,7 +247,7 @@ func TestCreateContainerFromPrivateRegistry(t *testing.T) {
 	// using the same credentials as in the Docker Registry
 	setAuthConfig(t, registryHost, "testuser", "testpassword")
 
-	ctx := context.Background()
+	ctx := t.Context()
 
 	redisContainer, err := Run(ctx, registryHost+"/redis:5.0-alpine", WithAlwaysPull(), WithExposedPorts("6379/tcp"), WithWaitStrategy(wait.ForLog("Ready to accept connections")))
 	CleanupContainer(t, redisContainer)
@@ -256,7 +256,7 @@ func TestCreateContainerFromPrivateRegistry(t *testing.T) {
 
 func prepareLocalRegistryWithAuth(t *testing.T) string {
 	t.Helper()
-	ctx := context.Background()
+	ctx := t.Context()
 	wd, err := os.Getwd()
 	require.NoError(t, err)
 	// copyDirectoryToContainer {
@@ -338,8 +338,10 @@ func localAddress(t *testing.T) string {
 	if os.Getenv("WSL_DISTRO_NAME") == "" {
 		return "localhost"
 	}
+	ctx := context.Background()
 
-	conn, err := net.Dial("udp", "golang.org:80")
+	d := &net.Dialer{}
+	conn, err := d.DialContext(ctx, "udp", "golang.org:80")
 	require.NoError(t, err)
 	defer conn.Close()
 
diff --git a/docker_test.go b/docker_test.go
index e4506e756e..38932195d8 100644
--- a/docker_test.go
+++ b/docker_test.go
@@ -81,8 +81,12 @@ func TestContainerWithHostNetworkOptions(t *testing.T) {
 	endpoint, err := nginxC.PortEndpoint(ctx, nginxHighPort, "http")
 	require.NoErrorf(t, err, "Expected server endpoint")
 
-	_, err = http.Get(endpoint)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := http.DefaultClient.Do(req)
 	require.NoErrorf(t, err, "Expected OK response")
+	require.NoError(t, resp.Body.Close())
 }
 
 func TestContainerWithHostNetworkOptions_UseExposePortsFromImageConfigs(t *testing.T) {
@@ -103,11 +107,14 @@ func TestContainerWithHostNetworkOptions_UseExposePortsFromImageConfigs(t *testi
 	endpoint, err := nginxC.Endpoint(ctx, "http")
 	require.NoErrorf(t, err, "Expected server endpoint")
 
-	resp, err := http.Get(endpoint)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := http.DefaultClient.Do(req)
 	require.NoError(t, err)
-	defer resp.Body.Close()
 
 	require.Equalf(t, http.StatusOK, resp.StatusCode, "Expected status code %d. Got %d.", http.StatusOK, resp.StatusCode)
+	require.NoError(t, resp.Body.Close())
 }
 
 func TestContainerWithHostNetwork(t *testing.T) {
@@ -140,14 +147,22 @@ func TestContainerWithHostNetwork(t *testing.T) {
 	require.NoErrorf(t, err, "Expected port endpoint %s", portEndpoint)
 	t.Log(portEndpoint)
 
-	_, err = http.Get(portEndpoint)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, portEndpoint, http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := http.DefaultClient.Do(req)
 	require.NoErrorf(t, err, "Expected OK response")
+	require.NoError(t, resp.Body.Close())
 
 	host, err := nginxC.Host(ctx)
 	require.NoErrorf(t, err, "Expected host %s", host)
 
-	_, err = http.Get("http://" + host + ":8080")
+	req, err = http.NewRequestWithContext(ctx, http.MethodGet, "http://"+host+":8080", http.NoBody)
+	require.NoError(t, err)
+
+	resp, err = http.DefaultClient.Do(req)
 	require.NoErrorf(t, err, "Expected OK response")
+	require.NoError(t, resp.Body.Close())
 }
 
 func TestContainerReturnItsContainerID(t *testing.T) {
@@ -318,20 +333,26 @@ func TestTwoContainersExposingTheSamePort(t *testing.T) {
 	endpointA, err := nginxA.PortEndpoint(ctx, nginxDefaultPort, "http")
 	require.NoError(t, err)
 
-	resp, err := http.Get(endpointA)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpointA, http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := http.DefaultClient.Do(req)
 	require.NoError(t, err)
-	defer resp.Body.Close()
 
 	require.Equalf(t, http.StatusOK, resp.StatusCode, "Expected status code %d. Got %d.", http.StatusOK, resp.StatusCode)
+	require.NoError(t, resp.Body.Close())
 
 	endpointB, err := nginxB.PortEndpoint(ctx, nginxDefaultPort, "http")
 	require.NoError(t, err)
 
-	resp, err = http.Get(endpointB)
+	req, err = http.NewRequestWithContext(ctx, http.MethodGet, endpointB, http.NoBody)
+	require.NoError(t, err)
+
+	resp, err = http.DefaultClient.Do(req)
 	require.NoError(t, err)
-	defer resp.Body.Close()
 
 	require.Equalf(t, http.StatusOK, resp.StatusCode, "Expected status code %d. Got %d.", http.StatusOK, resp.StatusCode)
+	require.NoError(t, resp.Body.Close())
 }
 
 func TestContainerCreation(t *testing.T) {
@@ -347,11 +368,14 @@ func TestContainerCreation(t *testing.T) {
 	endpoint, err := nginxC.PortEndpoint(ctx, nginxDefaultPort, "http")
 	require.NoError(t, err)
 
-	resp, err := http.Get(endpoint)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := http.DefaultClient.Do(req)
 	require.NoError(t, err)
-	defer resp.Body.Close()
 
 	require.Equalf(t, http.StatusOK, resp.StatusCode, "Expected status code %d. Got %d.", http.StatusOK, resp.StatusCode)
+	require.NoError(t, resp.Body.Close())
 
 	networkIP, err := nginxC.ContainerIP(ctx)
 	require.NoError(t, err)
@@ -408,11 +432,14 @@ func TestContainerCreationWithName(t *testing.T) {
 	endpoint, err := nginxC.PortEndpoint(ctx, nginxDefaultPort, "http")
 	require.NoError(t, err)
 
-	resp, err := http.Get(endpoint)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := http.DefaultClient.Do(req)
 	require.NoError(t, err)
-	defer resp.Body.Close()
 
 	require.Equalf(t, http.StatusOK, resp.StatusCode, "Expected status code %d. Got %d.", http.StatusOK, resp.StatusCode)
+	require.NoError(t, resp.Body.Close())
 }
 
 func TestContainerCreationAndWaitForListeningPortLongEnough(t *testing.T) {
@@ -428,11 +455,15 @@ func TestContainerCreationAndWaitForListeningPortLongEnough(t *testing.T) {
 
 	origin, err := nginxC.PortEndpoint(ctx, nginxDefaultPort, "http")
 	require.NoError(t, err)
-	resp, err := http.Get(origin)
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, origin, http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := http.DefaultClient.Do(req)
 	require.NoError(t, err)
-	defer resp.Body.Close()
 
 	require.Equalf(t, http.StatusOK, resp.StatusCode, "Expected status code %d. Got %d.", http.StatusOK, resp.StatusCode)
+	require.NoError(t, resp.Body.Close())
 }
 
 func TestContainerCreationTimesOut(t *testing.T) {
@@ -459,11 +490,15 @@ func TestContainerRespondsWithHttp200ForIndex(t *testing.T) {
 
 	origin, err := nginxC.PortEndpoint(ctx, nginxDefaultPort, "http")
 	require.NoError(t, err)
-	resp, err := http.Get(origin)
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, origin, http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := http.DefaultClient.Do(req)
 	require.NoError(t, err)
-	defer resp.Body.Close()
 
 	require.Equalf(t, http.StatusOK, resp.StatusCode, "Expected status code %d. Got %d.", http.StatusOK, resp.StatusCode)
+	require.NoError(t, resp.Body.Close())
 }
 
 func TestContainerCreationTimesOutWithHttp(t *testing.T) {
@@ -529,14 +564,17 @@ func Test_BuildContainerFromDockerfileWithBuildArgs(t *testing.T) {
 	ep, err := c.Endpoint(ctx, "http")
 	require.NoError(t, err)
 
-	resp, err := http.Get(ep + "/env")
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep+"/env", http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := http.DefaultClient.Do(req)
 	require.NoError(t, err)
-	defer resp.Body.Close()
 
 	body, err := io.ReadAll(resp.Body)
 	require.NoError(t, err)
 	require.Equal(t, http.StatusAccepted, resp.StatusCode)
 	require.Equal(t, ba, string(body))
+	require.NoError(t, resp.Body.Close())
 }
 
 func Test_BuildContainerFromDockerfileWithBuildLog(t *testing.T) {
@@ -842,9 +880,31 @@ func ExampleContainer_MappedPort() {
 	}
 
 	// buildingAddresses {
-	ip, _ := nginxC.Host(ctx)
-	port, _ := nginxC.MappedPort(ctx, "80")
-	_, _ = http.Get(fmt.Sprintf("http://%s:%s", ip, port.Port()))
+	ip, err := nginxC.Host(ctx)
+	if err != nil {
+		log.Printf("failed to get container host: %s", err)
+		return
+	}
+	port, err := nginxC.MappedPort(ctx, "80")
+	if err != nil {
+		log.Printf("failed to get container mapped port: %s", err)
+		return
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, fmt.Sprintf("http://%s:%s", ip, port.Port()), http.NoBody)
+	if err != nil {
+		log.Printf("failed to create request: %s", err)
+		return
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		log.Printf("failed to do request: %s", err)
+		return
+	}
+	if resp.StatusCode != http.StatusOK {
+		log.Printf("expected status code %d, got %d", http.StatusOK, resp.StatusCode)
+		return
+	}
+	defer resp.Body.Close()
 	// }
 
 	state, err := nginxC.State(ctx)
diff --git a/docs/features/creating_container.md b/docs/features/creating_container.md
index 383198df86..3f21eac5aa 100644
--- a/docs/features/creating_container.md
+++ b/docs/features/creating_container.md
@@ -67,6 +67,7 @@ import (
     "net/http"
     "testing"
 
+    "github.com/stretchr/testify/require"
     "github.com/testcontainers/testcontainers-go"
     "github.com/testcontainers/testcontainers-go/wait"
 )
@@ -126,8 +127,14 @@ func TestIntegrationNginxLatestReturn(t *testing.T) {
     testcontainers.CleanupContainer(t, nginxC)
     require.NoError(t, err)
 
-    resp, err := http.Get(nginxC.URI)
+    req, err := http.NewRequestWithContext(ctx, http.MethodGet, nginxC.URI, http.NoBody)
+    require.NoError(t, err)
+
+    resp, err := http.DefaultClient.Do(req)
+    require.NoError(t, err)
+
     require.Equal(t, http.StatusOK, resp.StatusCode)
+    require.NoError(t, resp.Body.Close())
 }
 ```
 
diff --git a/examples/nginx/nginx_test.go b/examples/nginx/nginx_test.go
index fe662daf07..5cb4fe08a3 100644
--- a/examples/nginx/nginx_test.go
+++ b/examples/nginx/nginx_test.go
@@ -21,7 +21,12 @@ func TestIntegrationNginxLatestReturn(t *testing.T) {
 	testcontainers.CleanupContainer(t, nginxC)
 	require.NoError(t, err)
 
-	resp, err := http.Get(nginxC.URI)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, nginxC.URI, http.NoBody)
 	require.NoError(t, err)
+
+	resp, err := http.DefaultClient.Do(req)
+	require.NoError(t, err)
+
 	require.Equal(t, http.StatusOK, resp.StatusCode)
+	require.NoError(t, resp.Body.Close())
 }
diff --git a/generic_test.go b/generic_test.go
index 99e207562f..488ca061dc 100644
--- a/generic_test.go
+++ b/generic_test.go
@@ -152,7 +152,7 @@ func TestGenericReusableContainerInSubprocess(t *testing.T) {
 func createReuseContainerInSubprocess(t *testing.T) string {
 	t.Helper()
 	// force verbosity in subprocesses, so that the output is printed
-	cmd := exec.Command(os.Args[0], "-test.run=TestHelperContainerStarterProcess", "-test.v=true")
+	cmd := exec.CommandContext(t.Context(), os.Args[0], "-test.run=TestHelperContainerStarterProcess", "-test.v=true")
 	cmd.Env = append(os.Environ(), "GO_WANT_HELPER_PROCESS=1")
 
 	output, err := cmd.CombinedOutput()
diff --git a/internal/core/docker_host.go b/internal/core/docker_host.go
index 73ff0a9776..1945a063d3 100644
--- a/internal/core/docker_host.go
+++ b/internal/core/docker_host.go
@@ -44,7 +44,7 @@ var (
 // see https://github.com/testcontainers/testcontainers-java/blob/main/core/src/main/java/org/testcontainers/dockerclient/DockerClientConfigUtils.java#L46
 func DefaultGatewayIP() (string, error) {
 	// see https://github.com/testcontainers/testcontainers-java/blob/3ad8d80e2484864e554744a4800a81f6b7982168/core/src/main/java/org/testcontainers/dockerclient/DockerClientConfigUtils.java#L27
-	cmd := exec.Command("sh", "-c", "ip route|awk '/default/ { print $3 }'")
+	cmd := exec.CommandContext(context.Background(), "sh", "-c", "ip route|awk '/default/ { print $3 }'")
 	stdout, err := cmd.Output()
 	if err != nil {
 		return "", errors.New("failed to detect docker host")
diff --git a/logconsumer_test.go b/logconsumer_test.go
index cfbd763d32..db448cd557 100644
--- a/logconsumer_test.go
+++ b/logconsumer_test.go
@@ -95,15 +95,25 @@ func Test_LogConsumerGetsCalled(t *testing.T) {
 	ep, err := c.Endpoint(ctx, "http")
 	require.NoError(t, err)
 
-	_, err = http.Get(ep + "/stdout?echo=hello")
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep+"/stdout?echo=hello", http.NoBody)
 	require.NoError(t, err)
 
-	_, err = http.Get(ep + "/stdout?echo=there")
+	_, err = http.DefaultClient.Do(req)
 	require.NoError(t, err)
 
-	_, err = http.Get(ep + "/stdout?echo=" + lastMessage)
+	req, err = http.NewRequestWithContext(ctx, http.MethodGet, ep+"/stdout?echo=there", http.NoBody)
 	require.NoError(t, err)
 
+	_, err = http.DefaultClient.Do(req)
+	require.NoError(t, err)
+
+	req, err = http.NewRequestWithContext(ctx, http.MethodGet, ep+"/stdout?echo="+lastMessage, http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := http.DefaultClient.Do(req)
+	require.NoError(t, err)
+	require.NoError(t, resp.Body.Close())
+
 	select {
 	case <-g.Done:
 	case <-time.After(5 * time.Second):
@@ -154,13 +164,23 @@ func Test_ShouldRecognizeLogTypes(t *testing.T) {
 	ep, err := c.Endpoint(ctx, "http")
 	require.NoError(t, err)
 
-	_, err = http.Get(ep + "/stdout?echo=this-is-stdout")
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep+"/stdout?echo=this-is-stdout", http.NoBody)
+	require.NoError(t, err)
+
+	_, err = http.DefaultClient.Do(req)
 	require.NoError(t, err)
 
-	_, err = http.Get(ep + "/stderr?echo=this-is-stderr")
+	req, err = http.NewRequestWithContext(ctx, http.MethodGet, ep+"/stderr?echo=this-is-stderr", http.NoBody)
 	require.NoError(t, err)
 
-	_, err = http.Get(ep + "/stdout?echo=" + lastMessage)
+	resp, err := http.DefaultClient.Do(req)
+	require.NoError(t, err)
+	require.NoError(t, resp.Body.Close())
+
+	req, err = http.NewRequestWithContext(ctx, http.MethodGet, ep+"/stdout?echo="+lastMessage, http.NoBody)
+	require.NoError(t, err)
+
+	_, err = http.DefaultClient.Do(req)
 	require.NoError(t, err)
 
 	<-g.Ack
@@ -204,11 +224,19 @@ func Test_MultipleLogConsumers(t *testing.T) {
 	ep, err := c.Endpoint(ctx, "http")
 	require.NoError(t, err)
 
-	_, err = http.Get(ep + "/stdout?echo=mlem")
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep+"/stdout?echo=mlem", http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := http.DefaultClient.Do(req)
+	require.NoError(t, err)
+	require.NoError(t, resp.Body.Close())
+
+	req, err = http.NewRequestWithContext(ctx, http.MethodGet, ep+"/stdout?echo="+lastMessage, http.NoBody)
 	require.NoError(t, err)
 
-	_, err = http.Get(ep + "/stdout?echo=" + lastMessage)
+	resp, err = http.DefaultClient.Do(req)
 	require.NoError(t, err)
+	require.NoError(t, resp.Body.Close())
 
 	<-first.Done
 	<-second.Done
@@ -412,14 +440,26 @@ func TestContainerLogsEnableAtStart(t *testing.T) {
 	ep, err := c.Endpoint(ctx, "http")
 	require.NoError(t, err)
 
-	_, err = http.Get(ep + "/stdout?echo=hello")
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep+"/stdout?echo=hello", http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := http.DefaultClient.Do(req)
+	require.NoError(t, err)
+	require.NoError(t, resp.Body.Close())
+
+	req, err = http.NewRequestWithContext(ctx, http.MethodGet, ep+"/stdout?echo=there", http.NoBody)
+	require.NoError(t, err)
+
+	resp, err = http.DefaultClient.Do(req)
 	require.NoError(t, err)
+	require.NoError(t, resp.Body.Close())
 
-	_, err = http.Get(ep + "/stdout?echo=there")
+	req, err = http.NewRequestWithContext(ctx, http.MethodGet, ep+"/stdout?echo="+lastMessage, http.NoBody)
 	require.NoError(t, err)
 
-	_, err = http.Get(ep + "/stdout?echo=" + lastMessage)
+	resp, err = http.DefaultClient.Do(req)
 	require.NoError(t, err)
+	require.NoError(t, resp.Body.Close())
 
 	select {
 	case <-g.Done:
@@ -554,11 +594,19 @@ func Test_MultiContainerLogConsumer_CancelledContext(t *testing.T) {
 	ep1, err := c.Endpoint(ctx, "http")
 	require.NoError(t, err)
 
-	_, err = http.Get(ep1 + "/stdout?echo=hello1")
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep1+"/stdout?echo=hello1", http.NoBody)
 	require.NoError(t, err)
 
-	_, err = http.Get(ep1 + "/stdout?echo=there1")
+	resp, err := http.DefaultClient.Do(req)
 	require.NoError(t, err)
+	require.NoError(t, resp.Body.Close())
+
+	req, err = http.NewRequestWithContext(ctx, http.MethodGet, ep1+"/stdout?echo=there1", http.NoBody)
+	require.NoError(t, err)
+
+	resp, err = http.DefaultClient.Do(req)
+	require.NoError(t, err)
+	require.NoError(t, resp.Body.Close())
 
 	second := TestLogConsumer{
 		msgs:     []string{},
@@ -585,11 +633,19 @@ func Test_MultiContainerLogConsumer_CancelledContext(t *testing.T) {
 	ep2, err := c2.Endpoint(ctx, "http")
 	require.NoError(t, err)
 
-	_, err = http.Get(ep2 + "/stdout?echo=hello2")
+	req, err = http.NewRequestWithContext(ctx, http.MethodGet, ep2+"/stdout?echo=hello2", http.NoBody)
+	require.NoError(t, err)
+
+	resp, err = http.DefaultClient.Do(req)
+	require.NoError(t, err)
+	require.NoError(t, resp.Body.Close())
+
+	req, err = http.NewRequestWithContext(ctx, http.MethodGet, ep2+"/stdout?echo=there2", http.NoBody)
 	require.NoError(t, err)
 
-	_, err = http.Get(ep2 + "/stdout?echo=there2")
+	resp, err = http.DefaultClient.Do(req)
 	require.NoError(t, err)
+	require.NoError(t, resp.Body.Close())
 
 	// Deliberately calling context cancel
 	cancel()
diff --git a/modulegen/internal/tools/exec.go b/modulegen/internal/tools/exec.go
index c4aae7a79d..d45eec6df6 100644
--- a/modulegen/internal/tools/exec.go
+++ b/modulegen/internal/tools/exec.go
@@ -1,6 +1,7 @@
 package tools
 
 import (
+	"context"
 	"fmt"
 	"os/exec"
 )
@@ -8,7 +9,7 @@ import (
 // GoModTidy synchronizes the dependencies for a module or example,
 // running the `go mod tidy` command in the given directory.
 func GoModTidy(cmdDir string) error {
-	if err := runCommand(cmdDir, "go", "mod", "tidy"); err != nil {
+	if err := runCommand(context.Background(), cmdDir, "go", "mod", "tidy"); err != nil {
 		return fmt.Errorf("mod tidy dependencies: %w", err)
 	}
 	return nil
@@ -17,7 +18,7 @@ func GoModTidy(cmdDir string) error {
 // GoVet checks the generated code for errors,
 // running the `go vet ./...` command in the given directory.
 func GoVet(cmdDir string) error {
-	if err := runCommand(cmdDir, "go", "vet", "./..."); err != nil {
+	if err := runCommand(context.Background(), cmdDir, "go", "vet", "./..."); err != nil {
 		return fmt.Errorf("go vet generated code: %w", err)
 	}
 	return nil
@@ -25,14 +26,14 @@ func GoVet(cmdDir string) error {
 
 // MakeLint runs the `make lint` command in the given directory.
 func MakeLint(cmdDir string) error {
-	if err := runCommand(cmdDir, "make", "lint"); err != nil {
+	if err := runCommand(context.Background(), cmdDir, "make", "lint"); err != nil {
 		return fmt.Errorf("make lint module: %w", err)
 	}
 	return nil
 }
 
-func runCommand(cmdDir string, command string, args ...string) error {
-	cmd := exec.Command(command, args...)
+func runCommand(ctx context.Context, cmdDir string, command string, args ...string) error {
+	cmd := exec.CommandContext(ctx, command, args...)
 	cmd.Dir = cmdDir
 	return cmd.Run()
 }
diff --git a/modules/artemis/artemis_test.go b/modules/artemis/artemis_test.go
index 380b3b0cbf..8296a5e7d6 100644
--- a/modules/artemis/artemis_test.go
+++ b/modules/artemis/artemis_test.go
@@ -73,10 +73,14 @@ func TestArtemis(t *testing.T) {
 			// }
 			require.NoError(t, err)
 
-			res, err := http.Get(u)
+			req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, http.NoBody)
+			require.NoError(t, err)
+
+			res, err := http.DefaultClient.Do(req)
 			require.NoError(t, err, "failed to access console")
-			res.Body.Close()
+
 			require.Equal(t, http.StatusOK, res.StatusCode, "failed to access console")
+			require.NoError(t, res.Body.Close())
 
 			if test.user != "" {
 				require.Equal(t, test.user, ctr.User(), "unexpected user")
@@ -125,17 +129,21 @@ func TestArtemis(t *testing.T) {
 
 func expectQueue(t *testing.T, container *artemis.Container, queueName string) {
 	t.Helper()
+	ctx := t.Context()
+
+	u, err := container.ConsoleURL(ctx)
+	require.NoError(t, err)
 
-	u, err := container.ConsoleURL(context.Background())
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u+`/jolokia/read/org.apache.activemq.artemis:broker="0.0.0.0"/QueueNames`, http.NoBody)
 	require.NoError(t, err)
 
-	r, err := http.Get(u + `/jolokia/read/org.apache.activemq.artemis:broker="0.0.0.0"/QueueNames`)
+	r, err := http.DefaultClient.Do(req)
 	require.NoError(t, err, "failed to request QueueNames")
-	defer r.Body.Close()
 
 	var res struct{ Value []string }
 	err = json.NewDecoder(r.Body).Decode(&res)
 	require.NoError(t, err, "failed to decode QueueNames response")
 
 	require.Containsf(t, res.Value, queueName, "should contain queue")
+	require.NoError(t, r.Body.Close())
 }
diff --git a/modules/chroma/chroma_test.go b/modules/chroma/chroma_test.go
index 5d975c3602..91aabf1f30 100644
--- a/modules/chroma/chroma_test.go
+++ b/modules/chroma/chroma_test.go
@@ -1,7 +1,6 @@
 package chroma_test
 
 import (
-	"context"
 	"net/http"
 	"testing"
 
@@ -13,35 +12,37 @@ import (
 )
 
 func TestChroma(t *testing.T) {
-	ctx := context.Background()
-
-	ctr, err := chroma.Run(ctx, "chromadb/chroma:0.4.24")
+	ctr, err := chroma.Run(t.Context(), "chromadb/chroma:0.4.24")
 	testcontainers.CleanupContainer(t, ctr)
 	require.NoError(t, err)
 
 	t.Run("REST Endpoint retrieve docs site", func(tt *testing.T) {
+		ctx := tt.Context()
 		// restEndpoint {
 		restEndpoint, err := ctr.RESTEndpoint(ctx)
 		// }
 		require.NoErrorf(tt, err, "failed to get REST endpoint")
 
-		cli := &http.Client{}
-		resp, err := cli.Get(restEndpoint + "/docs")
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, restEndpoint+"/docs", http.NoBody)
+		require.NoErrorf(tt, err, "failed to create request")
+
+		resp, err := http.DefaultClient.Do(req)
 		require.NoErrorf(tt, err, "failed to perform GET request")
-		defer resp.Body.Close()
 
 		require.Equalf(tt, http.StatusOK, resp.StatusCode, "unexpected status code: %d", resp.StatusCode)
+		require.NoError(tt, resp.Body.Close())
 	})
 
 	t.Run("GetClient", func(tt *testing.T) {
+		ctx := tt.Context()
 		// restEndpoint {
-		endpoint, err := ctr.RESTEndpoint(context.Background())
+		endpoint, err := ctr.RESTEndpoint(ctx)
 		require.NoErrorf(tt, err, "failed to get REST endpoint")
 		chromaClient, err := chromago.NewClient(endpoint)
 		// }
 		require.NoErrorf(tt, err, "failed to create client")
 
-		hb, err := chromaClient.Heartbeat(context.TODO())
+		hb, err := chromaClient.Heartbeat(ctx)
 		require.NoError(tt, err)
 		require.NotNil(tt, hb["nanosecond heartbeat"])
 	})
diff --git a/modules/cockroachdb/examples_test.go b/modules/cockroachdb/examples_test.go
index a1259c218b..f2ac008a57 100644
--- a/modules/cockroachdb/examples_test.go
+++ b/modules/cockroachdb/examples_test.go
@@ -104,20 +104,20 @@ func ExampleRun_withInitOptions() {
 	}()
 
 	var interval string
-	if err := db.QueryRow("SHOW CLUSTER SETTING kv.range_merge.queue_interval").Scan(&interval); err != nil {
+	if err := db.QueryRowContext(ctx, "SHOW CLUSTER SETTING kv.range_merge.queue_interval").Scan(&interval); err != nil {
 		log.Printf("failed to scan row: %s", err)
 		return
 	}
 	fmt.Println(interval)
 
-	if err := db.QueryRow("SHOW CLUSTER SETTING jobs.registry.interval.gc").Scan(&interval); err != nil {
+	if err := db.QueryRowContext(ctx, "SHOW CLUSTER SETTING jobs.registry.interval.gc").Scan(&interval); err != nil {
 		log.Printf("failed to scan row: %s", err)
 		return
 	}
 	fmt.Println(interval)
 
 	var statsCollectionEnabled bool
-	if err := db.QueryRow("SHOW CLUSTER SETTING sql.stats.automatic_collection.enabled").Scan(&statsCollectionEnabled); err != nil {
+	if err := db.QueryRowContext(ctx, "SHOW CLUSTER SETTING sql.stats.automatic_collection.enabled").Scan(&statsCollectionEnabled); err != nil {
 		log.Printf("failed to scan row: %s", err)
 		return
 	}
diff --git a/modules/compose/compose_local.go b/modules/compose/compose_local.go
index 03088908c2..73e0ebfb56 100644
--- a/modules/compose/compose_local.go
+++ b/modules/compose/compose_local.go
@@ -294,12 +294,10 @@ type ExecError struct {
 }
 
 // execute executes a program with arguments and environment variables inside a specific directory
-func execute(
-	dirContext string, environment map[string]string, binary string, args []string,
-) ExecError {
+func execute(ctx context.Context, dirContext string, environment map[string]string, binary string, args []string) ExecError {
 	var errStdout, errStderr error
 
-	cmd := exec.Command(binary, args...)
+	cmd := exec.CommandContext(ctx, binary, args...)
 	cmd.Dir = dirContext
 	cmd.Env = os.Environ()
 
@@ -395,7 +393,7 @@ func executeCompose(dc *LocalDockerCompose, args []string) ExecError {
 	}
 	cmds = append(cmds, args...)
 
-	execErr := execute(pwd, environment, dc.Executable, cmds)
+	execErr := execute(context.Background(), pwd, environment, dc.Executable, cmds)
 	err := execErr.Error
 	if err != nil {
 		args := strings.Join(dc.Cmd, " ")
diff --git a/modules/consul/consul_test.go b/modules/consul/consul_test.go
index 6f359b7261..cf0b4cda81 100644
--- a/modules/consul/consul_test.go
+++ b/modules/consul/consul_test.go
@@ -1,7 +1,6 @@
 package consul_test
 
 import (
-	"context"
 	"net/http"
 	"path/filepath"
 	"testing"
@@ -14,7 +13,6 @@ import (
 )
 
 func TestConsul(t *testing.T) {
-	ctx := context.Background()
 	tests := []struct {
 		name string
 		opts []testcontainers.ContainerCustomizer
@@ -39,6 +37,7 @@ func TestConsul(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
+			ctx := t.Context()
 			ctr, err := consul.Run(ctx, "hashicorp/consul:1.15", test.opts...)
 			testcontainers.CleanupContainer(t, ctr)
 			require.NoError(t, err)
@@ -48,8 +47,13 @@ func TestConsul(t *testing.T) {
 			require.NoError(t, err)
 			require.NotEmpty(t, host)
 
-			res, err := http.Get("http://" + host)
+			req, err := http.NewRequestWithContext(ctx, http.MethodGet, "http://"+host, http.NoBody)
 			require.NoError(t, err)
+
+			res, err := http.DefaultClient.Do(req)
+			require.NoError(t, err)
+
+			defer res.Body.Close()
 			require.Equal(t, http.StatusOK, res.StatusCode)
 
 			cfg := capi.DefaultConfig()
diff --git a/modules/databend/databend_test.go b/modules/databend/databend_test.go
index c2d30ddc7b..0cebcebb09 100644
--- a/modules/databend/databend_test.go
+++ b/modules/databend/databend_test.go
@@ -32,12 +32,12 @@ func TestDatabend(t *testing.T) {
 	require.NoError(t, err)
 	defer db.Close()
 
-	err = db.Ping()
+	err = db.PingContext(ctx)
 	require.NoError(t, err)
 
-	_, err = db.Exec("CREATE TABLE IF NOT EXISTS a_table ( \n" +
-		" `col_1` VARCHAR(128) NOT NULL, \n" +
-		" `col_2` VARCHAR(128) NOT NULL \n" +
+	_, err = db.ExecContext(ctx, "CREATE TABLE IF NOT EXISTS a_table ( \n"+
+		" `col_1` VARCHAR(128) NOT NULL, \n"+
+		" `col_2` VARCHAR(128) NOT NULL \n"+
 		")")
 	require.NoError(t, err)
 }
@@ -58,17 +58,17 @@ func TestDatabendWithDefaultUserAndPassword(t *testing.T) {
 	db, err := sql.Open("databend", connectionString)
 	require.NoError(t, err)
 	defer db.Close()
-	err = db.Ping()
+	err = db.PingContext(ctx)
 	require.NoError(t, err)
 
 	var i int
-	row := db.QueryRow("select 1")
+	row := db.QueryRowContext(ctx, "select 1")
 	err = row.Scan(&i)
 	require.NoError(t, err)
 
-	_, err = db.Exec("CREATE TABLE IF NOT EXISTS a_table ( \n" +
-		" `col_1` VARCHAR(128) NOT NULL, \n" +
-		" `col_2` VARCHAR(128) NOT NULL \n" +
+	_, err = db.ExecContext(ctx, "CREATE TABLE IF NOT EXISTS a_table ( \n"+
+		" `col_1` VARCHAR(128) NOT NULL, \n"+
+		" `col_2` VARCHAR(128) NOT NULL \n"+
 		")")
 	require.NoError(t, err)
 }
diff --git a/modules/databend/examples_test.go b/modules/databend/examples_test.go
index ac284ef009..3864fc2139 100644
--- a/modules/databend/examples_test.go
+++ b/modules/databend/examples_test.go
@@ -74,7 +74,7 @@ func ExampleRun_connect() {
 	defer db.Close()
 
 	var i int
-	row := db.QueryRow("select 1")
+	row := db.QueryRowContext(ctx, "select 1")
 	err = row.Scan(&i)
 	if err != nil {
 		log.Printf("failed to scan result: %s", err)
diff --git a/modules/dolt/dolt.go b/modules/dolt/dolt.go
index b03dcdb435..1d46d89127 100644
--- a/modules/dolt/dolt.go
+++ b/modules/dolt/dolt.go
@@ -133,26 +133,26 @@ func (c *DoltContainer) initialize(ctx context.Context, createUser bool) error {
 		}
 	}()
 
-	if err = db.Ping(); err != nil {
+	if err = db.PingContext(ctx); err != nil {
 		return fmt.Errorf("error pinging db: %w", err)
 	}
 
 	// create database
-	_, err = db.Exec(fmt.Sprintf("CREATE DATABASE IF NOT EXISTS %s;", c.database))
+	_, err = db.ExecContext(ctx, fmt.Sprintf("CREATE DATABASE IF NOT EXISTS %s;", c.database))
 	if err != nil {
 		return fmt.Errorf("error creating database %s: %w", c.database, err)
 	}
 
 	if createUser {
 		// create user
-		_, err = db.Exec(fmt.Sprintf("CREATE USER IF NOT EXISTS '%s' IDENTIFIED BY '%s';", c.username, c.password))
+		_, err = db.ExecContext(ctx, fmt.Sprintf("CREATE USER IF NOT EXISTS '%s' IDENTIFIED BY '%s';", c.username, c.password))
 		if err != nil {
 			return fmt.Errorf("error creating user %s: %w", c.username, err)
 		}
 
 		q := fmt.Sprintf("GRANT ALL ON %s.* TO '%s';", c.database, c.username)
 		// grant user privileges
-		_, err = db.Exec(q)
+		_, err = db.ExecContext(ctx, q)
 		if err != nil {
 			return fmt.Errorf("error creating user %s: %w", c.username, err)
 		}
diff --git a/modules/dolt/dolt_test.go b/modules/dolt/dolt_test.go
index a1e46cc976..237cddfc7b 100644
--- a/modules/dolt/dolt_test.go
+++ b/modules/dolt/dolt_test.go
@@ -32,13 +32,13 @@ func TestDolt(t *testing.T) {
 	require.NoError(t, err)
 	defer db.Close()
 
-	err = db.Ping()
+	err = db.PingContext(ctx)
 	require.NoError(t, err)
 
-	_, err = db.Exec("CREATE TABLE IF NOT EXISTS a_table ( \n" +
-		" `col_1` VARCHAR(128) NOT NULL, \n" +
-		" `col_2` VARCHAR(128) NOT NULL, \n" +
-		" PRIMARY KEY (`col_1`, `col_2`) \n" +
+	_, err = db.ExecContext(ctx, "CREATE TABLE IF NOT EXISTS a_table ( \n"+
+		" `col_1` VARCHAR(128) NOT NULL, \n"+
+		" `col_2` VARCHAR(128) NOT NULL, \n"+
+		" PRIMARY KEY (`col_1`, `col_2`) \n"+
 		")")
 	require.NoError(t, err)
 }
@@ -114,13 +114,13 @@ func TestDoltWithRootUserAndEmptyPassword(t *testing.T) {
 	require.NoError(t, err)
 	defer db.Close()
 
-	err = db.Ping()
+	err = db.PingContext(ctx)
 	require.NoError(t, err)
 
-	_, err = db.Exec("CREATE TABLE IF NOT EXISTS a_table ( \n" +
-		" `col_1` VARCHAR(128) NOT NULL, \n" +
-		" `col_2` VARCHAR(128) NOT NULL, \n" +
-		" PRIMARY KEY (`col_1`, `col_2`) \n" +
+	_, err = db.ExecContext(ctx, "CREATE TABLE IF NOT EXISTS a_table ( \n"+
+		" `col_1` VARCHAR(128) NOT NULL, \n"+
+		" `col_2` VARCHAR(128) NOT NULL, \n"+
+		" PRIMARY KEY (`col_1`, `col_2`) \n"+
 		")")
 	require.NoError(t, err)
 }
@@ -141,14 +141,14 @@ func TestDoltWithScripts(t *testing.T) {
 	require.NoError(t, err)
 	defer db.Close()
 
-	err = db.Ping()
+	err = db.PingContext(ctx)
 	require.NoError(t, err)
 
-	stmt, err := db.Prepare("SELECT name from profile")
+	stmt, err := db.PrepareContext(ctx, "SELECT name from profile")
 	require.NoError(t, err)
 
 	defer stmt.Close()
-	row := stmt.QueryRow()
+	row := stmt.QueryRowContext(ctx)
 	var name string
 	err = row.Scan(&name)
 	require.NoError(t, err)
diff --git a/modules/dolt/examples_test.go b/modules/dolt/examples_test.go
index 54241bbcbb..fca5d6a315 100644
--- a/modules/dolt/examples_test.go
+++ b/modules/dolt/examples_test.go
@@ -76,17 +76,17 @@ func ExampleRun_connect() {
 	}
 	defer db.Close()
 
-	if err = db.Ping(); err != nil {
+	if err = db.PingContext(ctx); err != nil {
 		log.Printf("failed to ping database: %s", err)
 		return
 	}
-	stmt, err := db.Prepare("SELECT dolt_version();")
+	stmt, err := db.PrepareContext(ctx, "SELECT dolt_version();")
 	if err != nil {
 		log.Printf("failed to prepare sql statement: %s", err)
 		return
 	}
 	defer stmt.Close()
-	row := stmt.QueryRow()
+	row := stmt.QueryRowContext(ctx)
 	version := ""
 	err = row.Scan(&version)
 	if err != nil {
diff --git a/modules/elasticsearch/elasticsearch_test.go b/modules/elasticsearch/elasticsearch_test.go
index 7605f64d34..47c563945e 100644
--- a/modules/elasticsearch/elasticsearch_test.go
+++ b/modules/elasticsearch/elasticsearch_test.go
@@ -87,7 +87,7 @@ func TestElasticsearch(t *testing.T) {
 
 			httpClient := configureHTTPClient(esContainer)
 
-			req, err := http.NewRequest(http.MethodGet, esContainer.Settings.Address, nil)
+			req, err := http.NewRequestWithContext(ctx, http.MethodGet, esContainer.Settings.Address, nil)
 			require.NoError(t, err)
 
 			// set the password for the request using the Authentication header
@@ -175,7 +175,7 @@ func TestElasticsearch8WithoutCredentials(t *testing.T) {
 
 	httpClient := configureHTTPClient(ctr)
 
-	req, err := http.NewRequest(http.MethodGet, ctr.Settings.Address, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ctr.Settings.Address, nil)
 	require.NoError(t, err)
 
 	// elastic:changeme are the default credentials for Elasticsearch 8
diff --git a/modules/k6/k6.go b/modules/k6/k6.go
index 8b7104ff13..d22e01ba34 100644
--- a/modules/k6/k6.go
+++ b/modules/k6/k6.go
@@ -37,9 +37,9 @@ func (d *DownloadableFile) getDownloadPath() string {
 	return path.Join(d.DownloadDir, baseName)
 }
 
-func downloadFileFromDescription(d DownloadableFile) error {
+func downloadFileFromDescription(ctx context.Context, d DownloadableFile) error {
 	client := http.Client{Timeout: time.Second * 60}
-	req, err := http.NewRequest(http.MethodGet, d.Uri.String(), nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, d.Uri.String(), http.NoBody)
 	if err != nil {
 		return err
 	}
@@ -54,6 +54,7 @@ func downloadFileFromDescription(d DownloadableFile) error {
 	if err != nil {
 		return err
 	}
+	defer resp.Body.Close()
 
 	downloadedFile, err := os.Create(d.getDownloadPath())
 	if err != nil {
@@ -103,7 +104,7 @@ func WithTestScriptReader(reader io.Reader, scriptBaseName string) testcontainer
 
 // WithRemoteTestScript takes a RemoteTestFileDescription and copies to container
 func WithRemoteTestScript(d DownloadableFile) testcontainers.CustomizeRequestOption {
-	err := downloadFileFromDescription(d)
+	err := downloadFileFromDescription(context.Background(), d)
 	if err != nil {
 		return func(_ *testcontainers.GenericContainerRequest) error {
 			return fmt.Errorf("not able to download required test script: %w", err)
diff --git a/modules/localstack/examples_test.go b/modules/localstack/examples_test.go
index b2e6e877ab..c02c072734 100644
--- a/modules/localstack/examples_test.go
+++ b/modules/localstack/examples_test.go
@@ -236,11 +236,19 @@ func ExampleRun_usingLambdas() {
 
 	functionURL = strings.ReplaceAll(functionURL, "4566", mappedPort.Port())
 
-	resp, err := httpClient.Post(functionURL, "application/json", bytes.NewBufferString(`{"num1": "10", "num2": "10"}`))
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, functionURL, bytes.NewBufferString(`{"num1": "10", "num2": "10"}`))
+	if err != nil {
+		log.Printf("failed to create request: %s", err)
+		return
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := httpClient.Do(req)
 	if err != nil {
 		log.Printf("failed to send request to lambda function: %s", err)
 		return
 	}
+	defer resp.Body.Close()
 
 	jsonResponse, err := io.ReadAll(resp.Body)
 	if err != nil {
diff --git a/modules/mariadb/mariadb_test.go b/modules/mariadb/mariadb_test.go
index 0e7443563f..8a44bbab88 100644
--- a/modules/mariadb/mariadb_test.go
+++ b/modules/mariadb/mariadb_test.go
@@ -34,13 +34,13 @@ func TestMariaDB(t *testing.T) {
 	require.NoError(t, err)
 	defer db.Close()
 
-	err = db.Ping()
+	err = db.PingContext(ctx)
 	require.NoError(t, err)
 
-	_, err = db.Exec("CREATE TABLE IF NOT EXISTS a_table ( \n" +
-		" `col_1` VARCHAR(128) NOT NULL, \n" +
-		" `col_2` VARCHAR(128) NOT NULL, \n" +
-		" PRIMARY KEY (`col_1`, `col_2`) \n" +
+	_, err = db.ExecContext(ctx, "CREATE TABLE IF NOT EXISTS a_table ( \n"+
+		" `col_1` VARCHAR(128) NOT NULL, \n"+
+		" `col_2` VARCHAR(128) NOT NULL, \n"+
+		" PRIMARY KEY (`col_1`, `col_2`) \n"+
 		")")
 	require.NoError(t, err)
 }
@@ -74,13 +74,13 @@ func TestMariaDBWithRootUserAndEmptyPassword(t *testing.T) {
 	require.NoError(t, err)
 	defer db.Close()
 
-	err = db.Ping()
+	err = db.PingContext(ctx)
 	require.NoError(t, err)
 
-	_, err = db.Exec("CREATE TABLE IF NOT EXISTS a_table ( \n" +
-		" `col_1` VARCHAR(128) NOT NULL, \n" +
-		" `col_2` VARCHAR(128) NOT NULL, \n" +
-		" PRIMARY KEY (`col_1`, `col_2`) \n" +
+	_, err = db.ExecContext(ctx, "CREATE TABLE IF NOT EXISTS a_table ( \n"+
+		" `col_1` VARCHAR(128) NOT NULL, \n"+
+		" `col_2` VARCHAR(128) NOT NULL, \n"+
+		" PRIMARY KEY (`col_1`, `col_2`) \n"+
 		")")
 	require.NoError(t, err)
 }
@@ -111,18 +111,18 @@ func TestMariaDBWithConfigFile(t *testing.T) {
 	require.NoError(t, err)
 	defer db.Close()
 
-	err = db.Ping()
+	err = db.PingContext(ctx)
 	require.NoError(t, err)
 
 	// In MariaDB 10.2.2 and later, the default file format is Barracuda and Antelope is deprecated.
 	// Barracuda is a newer InnoDB file format. It supports the COMPACT, REDUNDANT, DYNAMIC and
 	// COMPRESSED row formats. Tables with large BLOB or TEXT columns in particular could benefit
 	// from the dynamic row format.
-	stmt, err := db.Prepare("SELECT @@GLOBAL.innodb_default_row_format")
+	stmt, err := db.PrepareContext(ctx, "SELECT @@GLOBAL.innodb_default_row_format")
 	require.NoError(t, err)
 
 	defer stmt.Close()
-	row := stmt.QueryRow()
+	row := stmt.QueryRowContext(ctx)
 	innodbFileFormat := ""
 	err = row.Scan(&innodbFileFormat)
 	require.NoError(t, err)
@@ -149,14 +149,14 @@ func assertDataCanBeFetched(t *testing.T, ctx context.Context, container *mariad
 	require.NoError(t, err)
 	defer db.Close()
 
-	err = db.Ping()
+	err = db.PingContext(ctx)
 	require.NoError(t, err)
 
-	stmt, err := db.Prepare("SELECT name from profile")
+	stmt, err := db.PrepareContext(ctx, "SELECT name from profile")
 	require.NoError(t, err)
 	defer stmt.Close()
 
-	row := stmt.QueryRow()
+	row := stmt.QueryRowContext(ctx)
 	var name string
 	err = row.Scan(&name)
 	require.NoError(t, err)
diff --git a/modules/meilisearch/meilisearch_test.go b/modules/meilisearch/meilisearch_test.go
index fe50c72258..262384bbb2 100644
--- a/modules/meilisearch/meilisearch_test.go
+++ b/modules/meilisearch/meilisearch_test.go
@@ -23,7 +23,7 @@ func TestMeilisearch(t *testing.T) {
 	address, err := ctr.Address(ctx)
 	require.NoError(t, err)
 
-	req, err := http.NewRequest(http.MethodGet, address, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, address, http.NoBody)
 	require.NoError(t, err)
 
 	resp, err := http.DefaultClient.Do(req)
@@ -46,7 +46,7 @@ func TestMeilisearch_WithDataDump(t *testing.T) {
 
 	client := http.DefaultClient
 
-	req, err := http.NewRequest(http.MethodGet, address, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, address, http.NoBody)
 	require.NoError(t, err)
 
 	resp, err := client.Do(req)
@@ -58,7 +58,7 @@ func TestMeilisearch_WithDataDump(t *testing.T) {
 	path, err := url.JoinPath(address, "/indexes/movies/documents/1212")
 	require.NoError(t, err)
 
-	req, err = http.NewRequest(http.MethodGet, path, nil)
+	req, err = http.NewRequestWithContext(ctx, http.MethodGet, path, http.NoBody)
 	require.NoError(t, err)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("Authorization", "Bearer my-master-key")
diff --git a/modules/mockserver/examples_test.go b/modules/mockserver/examples_test.go
index e642878af3..966faac3ff 100644
--- a/modules/mockserver/examples_test.go
+++ b/modules/mockserver/examples_test.go
@@ -76,19 +76,30 @@ func ExampleRun_connect() {
 		return
 	}
 
-	httpClient := &http.Client{}
-	resp, err := httpClient.Post(url+"/api/categories", "application/json", strings.NewReader(`{"name": "Tools"}`))
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url+"/api/categories", strings.NewReader(`{"name": "Tools"}`))
+	if err != nil {
+		log.Printf("failed to create request: %s", err)
+		return
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		log.Printf("failed to send request: %s", err)
 		return
 	}
 
+	defer func() {
+		if err := resp.Body.Close(); err != nil {
+			log.Printf("failed to close response body: %s", err)
+		}
+	}()
+
 	buf, err := io.ReadAll(resp.Body)
 	if err != nil {
 		log.Printf("failed to read response: %s", err)
 		return
 	}
-	resp.Body.Close()
 
 	fmt.Println(resp.StatusCode)
 	fmt.Println(string(buf))
diff --git a/modules/mssql/mssql_test.go b/modules/mssql/mssql_test.go
index 10052b8d40..ba7613f839 100644
--- a/modules/mssql/mssql_test.go
+++ b/modules/mssql/mssql_test.go
@@ -33,13 +33,13 @@ func TestMSSQLServer(t *testing.T) {
 	require.NoError(t, err)
 	defer db.Close()
 
-	err = db.Ping()
+	err = db.PingContext(ctx)
 	require.NoError(t, err)
 
-	_, err = db.Exec("CREATE TABLE a_table ( " +
-		" [col_1] NVARCHAR(128) NOT NULL, " +
-		" [col_2] NVARCHAR(128) NOT NULL, " +
-		" PRIMARY KEY ([col_1], [col_2]) " +
+	_, err = db.ExecContext(ctx, "CREATE TABLE a_table ( "+
+		" [col_1] NVARCHAR(128) NOT NULL, "+
+		" [col_2] NVARCHAR(128) NOT NULL, "+
+		" PRIMARY KEY ([col_1], [col_2]) "+
 		")")
 	require.NoError(t, err)
 }
@@ -88,13 +88,13 @@ func TestMSSQLServerWithConnectionStringParameters(t *testing.T) {
 
 	defer db.Close()
 
-	err = db.Ping()
+	err = db.PingContext(ctx)
 	require.NoError(t, err)
 
-	_, err = db.Exec("CREATE TABLE a_table ( " +
-		" [col_1] NVARCHAR(128) NOT NULL, " +
-		" [col_2] NVARCHAR(128) NOT NULL, " +
-		" PRIMARY KEY ([col_1], [col_2]) " +
+	_, err = db.ExecContext(ctx, "CREATE TABLE a_table ( "+
+		" [col_1] NVARCHAR(128) NOT NULL, "+
+		" [col_2] NVARCHAR(128) NOT NULL, "+
+		" PRIMARY KEY ([col_1], [col_2]) "+
 		")")
 	require.NoError(t, err)
 }
@@ -118,7 +118,7 @@ func TestMSSQLServerWithCustomStrongPassword(t *testing.T) {
 	require.NoError(t, err)
 	defer db.Close()
 
-	err = db.Ping()
+	err = db.PingContext(ctx)
 	require.NoError(t, err)
 }
 
diff --git a/modules/mysql/examples_test.go b/modules/mysql/examples_test.go
index 61ee33113d..4e05ad2117 100644
--- a/modules/mysql/examples_test.go
+++ b/modules/mysql/examples_test.go
@@ -80,17 +80,17 @@ func ExampleRun_connect() {
 	}
 	defer db.Close()
 
-	if err = db.Ping(); err != nil {
+	if err = db.PingContext(ctx); err != nil {
 		log.Printf("failed to ping MySQL: %s", err)
 		return
 	}
-	stmt, err := db.Prepare("SELECT @@GLOBAL.tmpdir")
+	stmt, err := db.PrepareContext(ctx, "SELECT @@GLOBAL.tmpdir")
 	if err != nil {
 		log.Printf("failed to prepare statement: %s", err)
 		return
 	}
 	defer stmt.Close()
-	row := stmt.QueryRow()
+	row := stmt.QueryRowContext(ctx)
 	tmpDir := ""
 	err = row.Scan(&tmpDir)
 	if err != nil {
diff --git a/modules/mysql/mysql_test.go b/modules/mysql/mysql_test.go
index 758ed600da..fb85320e5a 100644
--- a/modules/mysql/mysql_test.go
+++ b/modules/mysql/mysql_test.go
@@ -34,13 +34,13 @@ func TestMySQL(t *testing.T) {
 	require.NoError(t, err)
 	defer db.Close()
 
-	err = db.Ping()
+	err = db.PingContext(ctx)
 	require.NoError(t, err)
 
-	_, err = db.Exec("CREATE TABLE IF NOT EXISTS a_table ( \n" +
-		" `col_1` VARCHAR(128) NOT NULL, \n" +
-		" `col_2` VARCHAR(128) NOT NULL, \n" +
-		" PRIMARY KEY (`col_1`, `col_2`) \n" +
+	_, err = db.ExecContext(ctx, "CREATE TABLE IF NOT EXISTS a_table ( \n"+
+		" `col_1` VARCHAR(128) NOT NULL, \n"+
+		" `col_2` VARCHAR(128) NOT NULL, \n"+
+		" PRIMARY KEY (`col_1`, `col_2`) \n"+
 		")")
 	require.NoError(t, err)
 }
@@ -75,13 +75,13 @@ func TestMySQLWithRootUserAndEmptyPassword(t *testing.T) {
 	require.NoError(t, err)
 	defer db.Close()
 
-	err = db.Ping()
+	err = db.PingContext(ctx)
 	require.NoError(t, err)
 
-	_, err = db.Exec("CREATE TABLE IF NOT EXISTS a_table ( \n" +
-		" `col_1` VARCHAR(128) NOT NULL, \n" +
-		" `col_2` VARCHAR(128) NOT NULL, \n" +
-		" PRIMARY KEY (`col_1`, `col_2`) \n" +
+	_, err = db.ExecContext(ctx, "CREATE TABLE IF NOT EXISTS a_table ( \n"+
+		" `col_1` VARCHAR(128) NOT NULL, \n"+
+		" `col_2` VARCHAR(128) NOT NULL, \n"+
+		" PRIMARY KEY (`col_1`, `col_2`) \n"+
 		")")
 	require.NoError(t, err)
 }
@@ -102,14 +102,14 @@ func TestMySQLWithScripts(t *testing.T) {
 	require.NoError(t, err)
 	defer db.Close()
 
-	err = db.Ping()
+	err = db.PingContext(ctx)
 	require.NoError(t, err)
 
-	stmt, err := db.Prepare("SELECT name from profile")
+	stmt, err := db.PrepareContext(ctx, "SELECT name from profile")
 	require.NoError(t, err)
 	defer stmt.Close()
 
-	row := stmt.QueryRow()
+	row := stmt.QueryRowContext(ctx)
 	var name string
 	err = row.Scan(&name)
 	require.NoError(t, err)
diff --git a/modules/ollama/examples_test.go b/modules/ollama/examples_test.go
index c5a12d491c..9e34cc6c6d 100644
--- a/modules/ollama/examples_test.go
+++ b/modules/ollama/examples_test.go
@@ -86,17 +86,19 @@ func ExampleRun_withModel_llama2_http() {
 	"prompt":"Why is the sky blue?"
 }`
 
-	req, err := http.NewRequest(http.MethodPost, connectionStr+"/api/generate", strings.NewReader(payload))
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, connectionStr+"/api/generate", strings.NewReader(payload))
 	if err != nil {
 		log.Printf("failed to create request: %s", err)
 		return
 	}
+	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := httpClient.Do(req)
 	if err != nil {
 		log.Printf("failed to get response: %s", err)
 		return
 	}
+	defer resp.Body.Close()
 	// }
 
 	fmt.Println(resp.StatusCode)
@@ -319,11 +321,18 @@ func ExampleRun_withImageMount() {
 		return
 	}
 
-	resp, err := http.Get(connectionStr + "/api/tags")
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, connectionStr+"/api/tags", http.NoBody)
+	if err != nil {
+		log.Printf("failed to create request: %s", err)
+		return
+	}
+
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		log.Printf("failed to get request: %s", err)
 		return
 	}
+	defer resp.Body.Close()
 
 	fmt.Println(resp.StatusCode)
 
diff --git a/modules/ollama/ollama_test.go b/modules/ollama/ollama_test.go
index 40e54fda2a..101a05abc3 100644
--- a/modules/ollama/ollama_test.go
+++ b/modules/ollama/ollama_test.go
@@ -17,7 +17,7 @@ import (
 )
 
 func TestOllama(t *testing.T) {
-	ctx := context.Background()
+	ctx := t.Context()
 
 	ctr, err := ollama.Run(ctx, "ollama/ollama:0.5.7")
 	testcontainers.CleanupContainer(t, ctr)
@@ -29,21 +29,24 @@ func TestOllama(t *testing.T) {
 		// }
 		require.NoError(t, err)
 
-		httpClient := &http.Client{}
-		resp, err := httpClient.Get(connectionStr)
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, connectionStr, http.NoBody)
+		require.NoError(t, err)
+
+		resp, err := http.DefaultClient.Do(req)
 		require.NoError(t, err)
-		defer resp.Body.Close()
 
 		require.Equal(t, http.StatusOK, resp.StatusCode)
+		require.NoError(t, resp.Body.Close())
 	})
 
 	t.Run("Pull and Run Model", func(t *testing.T) {
 		model := "all-minilm"
+		ctx := t.Context()
 
-		_, _, err = ctr.Exec(context.Background(), []string{"ollama", "pull", model})
+		_, _, err = ctr.Exec(ctx, []string{"ollama", "pull", model})
 		require.NoError(t, err)
 
-		_, _, err = ctr.Exec(context.Background(), []string{"ollama", "run", model})
+		_, _, err = ctr.Exec(ctx, []string{"ollama", "run", model})
 		require.NoError(t, err)
 
 		assertLoadedModel(t, ctr)
@@ -55,13 +58,14 @@ func TestOllama(t *testing.T) {
 		// Defining the target image name based on the default image and a random string.
 		// Users can change the way this is generated, but it should be unique.
 		targetImage := fmt.Sprintf("%s-%s", ollama.DefaultOllamaImage, strings.ToLower(uuid.New().String()[:4]))
+		ctx := t.Context()
 
-		err := ctr.Commit(context.Background(), targetImage)
+		err := ctr.Commit(ctx, targetImage)
 		// }
 		require.NoError(t, err)
 
 		newOllamaContainer, err := ollama.Run(
-			context.Background(),
+			ctx,
 			targetImage,
 		)
 		testcontainers.CleanupContainer(t, newOllamaContainer)
@@ -80,10 +84,10 @@ func TestOllama_withReuse(t *testing.T) {
 
 	model := "all-minilm"
 
-	_, _, err = ctr.Exec(context.Background(), []string{"ollama", "pull", model})
+	_, _, err = ctr.Exec(ctx, []string{"ollama", "pull", model})
 	require.NoError(t, err)
 
-	_, _, err = ctr.Exec(context.Background(), []string{"ollama", "run", model})
+	_, _, err = ctr.Exec(ctx, []string{"ollama", "run", model})
 	require.NoError(t, err)
 
 	assertLoadedModel(t, ctr)
@@ -92,11 +96,12 @@ func TestOllama_withReuse(t *testing.T) {
 		ctr2, err := ollama.Run(ctx, "ollama/ollama:0.5.7", testcontainers.WithReuseByName("ollama-container"))
 		testcontainers.CleanupContainer(t, ctr2)
 		require.NoError(t, err)
+		ctx := t.Context()
 
-		_, _, err = ctr2.Exec(context.Background(), []string{"ollama", "pull", model})
+		_, _, err = ctr2.Exec(ctx, []string{"ollama", "pull", model})
 		require.NoError(t, err)
 
-		_, _, err = ctr2.Exec(context.Background(), []string{"ollama", "run", model})
+		_, _, err = ctr2.Exec(ctx, []string{"ollama", "run", model})
 		require.NoError(t, err)
 
 		assertLoadedModel(t, ctr2)
@@ -108,12 +113,14 @@ func TestOllama_withReuse(t *testing.T) {
 // contains the model name.
 func assertLoadedModel(t *testing.T, c *ollama.OllamaContainer) {
 	t.Helper()
-	url, err := c.ConnectionString(context.Background())
+	ctx := t.Context()
+	url, err := c.ConnectionString(ctx)
 	require.NoError(t, err)
 
-	httpCli := &http.Client{}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url+"/api/tags", nil)
+	require.NoError(t, err)
 
-	resp, err := httpCli.Get(url + "/api/tags")
+	resp, err := http.DefaultClient.Do(req)
 	require.NoError(t, err)
 	defer resp.Body.Close()
 
diff --git a/modules/openfga/examples_test.go b/modules/openfga/examples_test.go
index cef1784993..74c98c642f 100644
--- a/modules/openfga/examples_test.go
+++ b/modules/openfga/examples_test.go
@@ -46,7 +46,8 @@ func ExampleRun() {
 }
 
 func ExampleRun_connectToPlayground() {
-	openfgaContainer, err := openfga.Run(context.Background(), "openfga/openfga:v1.5.0")
+	ctx := context.Background()
+	openfgaContainer, err := openfga.Run(ctx, "openfga/openfga:v1.5.0")
 	defer func() {
 		if err := testcontainers.TerminateContainer(openfgaContainer); err != nil {
 			log.Printf("failed to terminate container: %s", err)
@@ -58,7 +59,7 @@ func ExampleRun_connectToPlayground() {
 	}
 
 	// playgroundEndpoint {
-	playgroundEndpoint, err := openfgaContainer.PlaygroundEndpoint(context.Background())
+	playgroundEndpoint, err := openfgaContainer.PlaygroundEndpoint(ctx)
 	if err != nil {
 		log.Printf("failed to get playground endpoint: %s", err)
 		return
@@ -67,11 +68,18 @@ func ExampleRun_connectToPlayground() {
 
 	httpClient := http.Client{}
 
-	resp, err := httpClient.Get(playgroundEndpoint)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, playgroundEndpoint, http.NoBody)
+	if err != nil {
+		log.Printf("failed to create request: %v", err)
+		return
+	}
+
+	resp, err := httpClient.Do(req)
 	if err != nil {
 		log.Printf("failed to get playground endpoint: %s", err)
 		return
 	}
+	defer resp.Body.Close()
 
 	fmt.Println(resp.StatusCode)
 
diff --git a/modules/opensearch/opensearch_test.go b/modules/opensearch/opensearch_test.go
index 15304dbfd6..b2ee14ebbb 100644
--- a/modules/opensearch/opensearch_test.go
+++ b/modules/opensearch/opensearch_test.go
@@ -22,12 +22,10 @@ func TestOpenSearch(t *testing.T) {
 		address, err := ctr.Address(ctx)
 		require.NoError(t, err)
 
-		client := &http.Client{}
-
-		req, err := http.NewRequest(http.MethodGet, address, nil)
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, address, nil)
 		require.NoError(t, err)
 
-		resp, err := client.Do(req)
+		resp, err := http.DefaultClient.Do(req)
 		require.NoError(t, err)
 		defer resp.Body.Close()
 	})
diff --git a/modules/postgres/postgres_test.go b/modules/postgres/postgres_test.go
index b429002b89..2ede2b624b 100644
--- a/modules/postgres/postgres_test.go
+++ b/modules/postgres/postgres_test.go
@@ -128,11 +128,11 @@ func TestPostgres(t *testing.T) {
 			require.NotNil(t, db)
 			defer db.Close()
 
-			result, err := db.Exec("CREATE TABLE IF NOT EXISTS test (id int, name varchar(255));")
+			result, err := db.ExecContext(ctx, "CREATE TABLE IF NOT EXISTS test (id int, name varchar(255));")
 			require.NoError(t, err)
 			require.NotNil(t, result)
 
-			result, err = db.Exec("INSERT INTO test (id, name) VALUES (1, 'test');")
+			result, err = db.ExecContext(ctx, "INSERT INTO test (id, name) VALUES (1, 'test');")
 			require.NoError(t, err)
 			require.NotNil(t, result)
 		})
@@ -239,7 +239,7 @@ func TestWithSSL(t *testing.T) {
 	require.NotNil(t, db)
 	defer db.Close()
 
-	result, err := db.Exec("SELECT * FROM testdb;")
+	result, err := db.ExecContext(ctx, "SELECT * FROM testdb;")
 	require.NoError(t, err)
 	require.NotNil(t, result)
 }
@@ -285,7 +285,7 @@ func TestWithInitScript(t *testing.T) {
 	defer db.Close()
 
 	// database created in init script. See testdata/init-user-db.sh
-	result, err := db.Exec("SELECT * FROM testdb;")
+	result, err := db.ExecContext(ctx, "SELECT * FROM testdb;")
 	require.NoError(t, err)
 	require.NotNil(t, result)
 }
@@ -335,9 +335,10 @@ func TestWithOrderedInitScript(t *testing.T) {
 	defer db.Close()
 
 	// database created in init script. See testdata/init-user-db.sh
-	rows, err := db.Query("SELECT COUNT(*) FROM testdb;")
+	rows, err := db.QueryContext(ctx, "SELECT COUNT(*) FROM testdb;")
 	require.NoError(t, err)
 	require.NotNil(t, rows)
+	defer rows.Close()
 	for rows.Next() {
 		var count int
 		err := rows.Scan(&count)
diff --git a/modules/pulsar/pulsar_test.go b/modules/pulsar/pulsar_test.go
index 1fa07923d0..43494a3a54 100644
--- a/modules/pulsar/pulsar_test.go
+++ b/modules/pulsar/pulsar_test.go
@@ -174,7 +174,10 @@ func TestPulsar(t *testing.T) {
 				Timeout: 30 * time.Second,
 			}
 
-			resp, err := httpClient.Get(serviceURL + "/admin/v2/persistent/public/default/test-topic/stats")
+			req, err := http.NewRequestWithContext(ctx, http.MethodGet, serviceURL+"/admin/v2/persistent/public/default/test-topic/stats", http.NoBody)
+			require.NoError(t, err)
+
+			resp, err := httpClient.Do(req)
 			require.NoError(t, err)
 			defer resp.Body.Close()
 
diff --git a/modules/qdrant/qdrant_test.go b/modules/qdrant/qdrant_test.go
index 57f98fe9fc..09037fb191 100644
--- a/modules/qdrant/qdrant_test.go
+++ b/modules/qdrant/qdrant_test.go
@@ -26,8 +26,10 @@ func TestQdrant(t *testing.T) {
 		// }
 		require.NoError(t, err)
 
-		cli := &http.Client{}
-		resp, err := cli.Get(restEndpoint)
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, restEndpoint, http.NoBody)
+		require.NoError(t, err)
+
+		resp, err := http.DefaultClient.Do(req)
 		require.NoError(t, err)
 		defer resp.Body.Close()
 
@@ -51,9 +53,12 @@ func TestQdrant(t *testing.T) {
 		// }
 		require.NoError(t, err)
 
-		cli := &http.Client{}
-		resp, err := cli.Get(webUI)
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, webUI, http.NoBody)
 		require.NoError(t, err)
+
+		resp, err := http.DefaultClient.Do(req)
+		require.NoError(t, err)
+
 		defer resp.Body.Close()
 
 		require.Equal(t, http.StatusOK, resp.StatusCode)
diff --git a/modules/registry/registry_test.go b/modules/registry/registry_test.go
index 81adbd2655..f16057aa47 100644
--- a/modules/registry/registry_test.go
+++ b/modules/registry/registry_test.go
@@ -19,7 +19,7 @@ import (
 )
 
 func TestRegistry_unauthenticated(t *testing.T) {
-	ctx := context.Background()
+	ctx := t.Context()
 	ctr, err := registry.Run(ctx, registry.DefaultImage)
 	testcontainers.CleanupContainer(t, ctr)
 	require.NoError(t, err)
@@ -27,15 +27,19 @@ func TestRegistry_unauthenticated(t *testing.T) {
 	httpAddress, err := ctr.Address(ctx)
 	require.NoError(t, err)
 
-	resp, err := http.Get(httpAddress + "/v2/_catalog")
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, httpAddress+"/v2/_catalog", http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := http.DefaultClient.Do(req)
 	require.NoError(t, err)
+
 	defer resp.Body.Close()
 
 	require.Equal(t, http.StatusOK, resp.StatusCode)
 }
 
 func TestRunContainer_authenticated(t *testing.T) {
-	ctx := context.Background()
+	ctx := t.Context()
 	registryContainer, err := registry.Run(
 		ctx,
 		registry.DefaultImage,
@@ -54,11 +58,10 @@ func TestRunContainer_authenticated(t *testing.T) {
 	require.NoError(t, err)
 
 	t.Run("HTTP connection without basic auth fails", func(t *testing.T) {
-		httpCli := http.Client{}
-		req, err := http.NewRequest(http.MethodGet, httpAddress+"/v2/_catalog", nil)
+		req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, httpAddress+"/v2/_catalog", nil)
 		require.NoError(t, err)
 
-		resp, err := httpCli.Do(req)
+		resp, err := http.DefaultClient.Do(req)
 		require.NoError(t, err)
 		defer resp.Body.Close()
 
@@ -66,13 +69,12 @@ func TestRunContainer_authenticated(t *testing.T) {
 	})
 
 	t.Run("HTTP connection with incorrect basic auth fails", func(t *testing.T) {
-		httpCli := http.Client{}
-		req, err := http.NewRequest(http.MethodGet, httpAddress+"/v2/_catalog", nil)
+		req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, httpAddress+"/v2/_catalog", nil)
 		require.NoError(t, err)
 
 		req.SetBasicAuth("foo", "bar")
 
-		resp, err := httpCli.Do(req)
+		resp, err := http.DefaultClient.Do(req)
 		require.NoError(t, err)
 		defer resp.Body.Close()
 
@@ -80,13 +82,12 @@ func TestRunContainer_authenticated(t *testing.T) {
 	})
 
 	t.Run("HTTP connection with basic auth succeeds", func(t *testing.T) {
-		httpCli := http.Client{}
-		req, err := http.NewRequest(http.MethodGet, httpAddress+"/v2/_catalog", nil)
+		req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, httpAddress+"/v2/_catalog", nil)
 		require.NoError(t, err)
 
 		req.SetBasicAuth("testuser", "testpassword")
 
-		resp, err := httpCli.Do(req)
+		resp, err := http.DefaultClient.Do(req)
 		require.NoError(t, err)
 		defer resp.Body.Close()
 
@@ -157,13 +158,12 @@ func TestRunContainer_authenticated_withCredentials(t *testing.T) {
 	httpAddress, err := registryContainer.Address(ctx)
 	require.NoError(t, err)
 
-	httpCli := http.Client{}
-	req, err := http.NewRequest(http.MethodGet, httpAddress+"/v2/_catalog", nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, httpAddress+"/v2/_catalog", nil)
 	require.NoError(t, err)
 
 	req.SetBasicAuth("testuser", "testpassword")
 
-	resp, err := httpCli.Do(req)
+	resp, err := http.DefaultClient.Do(req)
 	require.NoError(t, err)
 	defer resp.Body.Close()
 
@@ -206,7 +206,7 @@ func TestRunContainer_authenticated_htpasswd_atomic_per_container(t *testing.T)
 	client := http.Client{}
 
 	// 1. Wrong password against A must fail.
-	req, err := http.NewRequest(http.MethodGet, regA.addr+"/v2/_catalog", nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, regA.addr+"/v2/_catalog", nil)
 	r.NoError(err)
 	req.SetBasicAuth("testuser", regB.pass)
 	resp, err := client.Do(req)
@@ -222,7 +222,7 @@ func TestRunContainer_authenticated_htpasswd_atomic_per_container(t *testing.T)
 	_ = resp.Body.Close()
 
 	// 3. Correct password against B must succeed.
-	req, err = http.NewRequest(http.MethodGet, regB.addr+"/v2/_catalog", nil)
+	req, err = http.NewRequestWithContext(ctx, http.MethodGet, regB.addr+"/v2/_catalog", nil)
 	r.NoError(err)
 	req.SetBasicAuth("testuser", regB.pass)
 	resp, err = client.Do(req)
diff --git a/modules/socat/examples_test.go b/modules/socat/examples_test.go
index 0f6fa619b1..6a17edde72 100644
--- a/modules/socat/examples_test.go
+++ b/modules/socat/examples_test.go
@@ -58,11 +58,15 @@ func ExampleRun() {
 	}()
 
 	// readFromSocat {
-	httpClient := http.DefaultClient
-
 	baseURI := socatContainer.TargetURL(target.ExposedPort())
 
-	resp, err := httpClient.Get(baseURI.String() + "/ping")
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURI.String()+"/ping", http.NoBody)
+	if err != nil {
+		log.Printf("failed to create request: %v", err)
+		return
+	}
+
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		log.Printf("failed to get response: %v", err)
 		return
@@ -156,7 +160,13 @@ func ExampleRun_multipleTargets() {
 	for _, target := range targets {
 		baseURI := socatContainer.TargetURL(target.ExposedPort())
 
-		resp, err := httpClient.Get(baseURI.String() + "/ping")
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURI.String()+"/ping", http.NoBody)
+		if err != nil {
+			log.Printf("failed to create request: %v", err)
+			return
+		}
+
+		resp, err := httpClient.Do(req)
 		if err != nil {
 			log.Printf("failed to get response: %v", err)
 			return
diff --git a/modules/socat/socat_test.go b/modules/socat/socat_test.go
index 1b279bdb0b..aab76899fb 100644
--- a/modules/socat/socat_test.go
+++ b/modules/socat/socat_test.go
@@ -54,11 +54,15 @@ func TestRun_helloWorld(t *testing.T) {
 	baseURI := socatContainer.TargetURL(exposedPort)
 	require.NotNil(t, baseURI)
 
-	resp, err := httpClient.Get(baseURI.String() + "/ping")
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURI.String()+"/ping", http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := httpClient.Do(req)
 	require.NoError(t, err)
 
 	require.Equal(t, 200, resp.StatusCode)
 
+	defer resp.Body.Close()
 	body, err := io.ReadAll(resp.Body)
 	require.NoError(t, err)
 	require.Equal(t, "PONG", string(body))
@@ -101,7 +105,10 @@ func TestRun_helloWorldDifferentPort(t *testing.T) {
 	baseURI := socatContainer.TargetURL(target.ExposedPort())
 	require.NotNil(t, baseURI)
 
-	resp, err := httpClient.Get(baseURI.String() + "/ping")
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURI.String()+"/ping", http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := httpClient.Do(req)
 	require.NoError(t, err)
 
 	require.Equal(t, 200, resp.StatusCode)
@@ -187,11 +194,15 @@ func TestRun_multipleTargets(t *testing.T) {
 		baseURI := socatContainer.TargetURL(target.ExposedPort())
 		require.NotNil(t, baseURI)
 
-		resp, err := httpClient.Get(baseURI.String() + "/ping")
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURI.String()+"/ping", http.NoBody)
+		require.NoError(t, err)
+
+		resp, err := httpClient.Do(req)
 		require.NoError(t, err)
 
 		require.Equal(t, 200, resp.StatusCode)
 
+		defer resp.Body.Close()
 		body, err := io.ReadAll(resp.Body)
 		require.NoError(t, err)
 		require.Equal(t, "PONG", string(body))
diff --git a/modules/vault/vault_test.go b/modules/vault/vault_test.go
index 22b87930bb..0f52b64b9d 100644
--- a/modules/vault/vault_test.go
+++ b/modules/vault/vault_test.go
@@ -60,7 +60,8 @@ func TestVault(t *testing.T) {
 
 		t.Run("From HTTP request", func(t *testing.T) {
 			// httpRead {
-			request, _ := http.NewRequest(http.MethodGet, hostAddress+"/v1/secret/data/test1", nil)
+			request, err := http.NewRequestWithContext(ctx, http.MethodGet, hostAddress+"/v1/secret/data/test1", http.NoBody)
+			require.NoError(t, err)
 			request.Header.Add("X-Vault-Token", token)
 
 			response, err := http.DefaultClient.Do(request)
diff --git a/modules/vearch/vearch_test.go b/modules/vearch/vearch_test.go
index 4caf25e633..772868ce53 100644
--- a/modules/vearch/vearch_test.go
+++ b/modules/vearch/vearch_test.go
@@ -1,7 +1,6 @@
 package vearch_test
 
 import (
-	"context"
 	"net/http"
 	"testing"
 
@@ -12,7 +11,7 @@ import (
 )
 
 func TestVearch(t *testing.T) {
-	ctx := context.Background()
+	ctx := t.Context()
 
 	ctr, err := vearch.Run(ctx, "vearch/vearch:3.5.1")
 	testcontainers.CleanupContainer(t, ctr)
@@ -24,11 +23,13 @@ func TestVearch(t *testing.T) {
 		// }
 		require.NoError(t, err)
 
-		cli := &http.Client{}
-		resp, err := cli.Get(restEndpoint)
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, restEndpoint, http.NoBody)
+		require.NoError(t, err)
+
+		resp, err := http.DefaultClient.Do(req)
 		require.NoError(t, err)
-		defer resp.Body.Close()
 
+		defer resp.Body.Close()
 		require.Equal(t, http.StatusOK, resp.StatusCode)
 	})
 }
diff --git a/modules/weaviate/weaviate_test.go b/modules/weaviate/weaviate_test.go
index 1cf8b0fa6e..008937be49 100644
--- a/modules/weaviate/weaviate_test.go
+++ b/modules/weaviate/weaviate_test.go
@@ -18,27 +18,30 @@ import (
 )
 
 func TestWeaviate(t *testing.T) {
-	ctx := context.Background()
-
-	ctr, err := weaviate.Run(ctx, "semitechnologies/weaviate:1.29.0")
+	ctr, err := weaviate.Run(t.Context(), "semitechnologies/weaviate:1.29.0")
 	testcontainers.CleanupContainer(t, ctr)
 	require.NoError(t, err)
 
 	t.Run("HttpHostAddress", func(t *testing.T) {
+		ctx := t.Context()
 		// httpHostAddress {
 		schema, host, err := ctr.HttpHostAddress(ctx)
 		// }
 		require.NoError(t, err)
 
-		cli := &http.Client{}
-		resp, err := cli.Get(fmt.Sprintf("%s://%s", schema, host))
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, fmt.Sprintf("%s://%s", schema, host), http.NoBody)
+		require.NoError(t, err)
+
+		resp, err := http.DefaultClient.Do(req)
 		require.NoError(t, err)
+
 		defer resp.Body.Close()
 
 		require.Equal(t, http.StatusOK, resp.StatusCode)
 	})
 
 	t.Run("GrpcHostAddress", func(t *testing.T) {
+		ctx := t.Context()
 		// gRPCHostAddress {
 		host, err := ctr.GrpcHostAddress(ctx)
 		// }
@@ -56,6 +59,7 @@ func TestWeaviate(t *testing.T) {
 	})
 
 	t.Run("Weaviate client", func(tt *testing.T) {
+		ctx := t.Context()
 		httpScheme, httpHost, err := ctr.HttpHostAddress(ctx)
 		require.NoError(tt, err)
 		grpcHost, err := ctr.GrpcHostAddress(ctx)
diff --git a/modules/yugabytedb/yugabytedb_test.go b/modules/yugabytedb/yugabytedb_test.go
index 38a93f0c89..972464ba71 100644
--- a/modules/yugabytedb/yugabytedb_test.go
+++ b/modules/yugabytedb/yugabytedb_test.go
@@ -38,7 +38,7 @@ func TestYugabyteDB_YSQL(t *testing.T) {
 		require.NoError(t, err)
 		require.NotNil(t, db)
 
-		err = db.Ping()
+		err = db.PingContext(ctx)
 		require.NoError(t, err)
 	})
 
@@ -66,7 +66,7 @@ func TestYugabyteDB_YSQL(t *testing.T) {
 		require.NoError(t, err)
 		require.NotNil(t, db)
 
-		err = db.Ping()
+		err = db.PingContext(ctx)
 		require.NoError(t, err)
 	})
 }
diff --git a/testcontainers_test.go b/testcontainers_test.go
index 6c06d87483..ee524802a0 100644
--- a/testcontainers_test.go
+++ b/testcontainers_test.go
@@ -47,14 +47,15 @@ func TestSessionID(t *testing.T) {
 		env := append(os.Environ(), "TESTCONTAINERS_SESSION_ID_HELPER=1")
 
 		re := regexp.MustCompile(">>>(.*)<<<")
+		ctx := t.Context()
 
-		cmd1 := exec.Command("go", args...)
+		cmd1 := exec.CommandContext(ctx, "go", args...)
 		cmd1.Env = env
 		stdoutStderr1, err := cmd1.CombinedOutput()
 		require.NoErrorf(t, err, "cmd1.Run() failed with %s", err)
 		sessionID1 := re.FindString(string(stdoutStderr1))
 
-		cmd2 := exec.Command("go", args...)
+		cmd2 := exec.CommandContext(ctx, "go", args...)
 		cmd2.Env = env
 		stdoutStderr2, err := cmd2.CombinedOutput()
 		require.NoErrorf(t, err, "cmd2.Run() failed with %s", err)
diff --git a/wait/host_port_test.go b/wait/host_port_test.go
index cd89d21918..448de0714e 100644
--- a/wait/host_port_test.go
+++ b/wait/host_port_test.go
@@ -19,7 +19,8 @@ import (
 )
 
 func TestWaitForListeningPortSucceeds(t *testing.T) {
-	listener, err := net.Listen("tcp", "localhost:0")
+	ln := &net.ListenConfig{}
+	listener, err := ln.Listen(t.Context(), "tcp", "localhost:0")
 	require.NoError(t, err)
 	defer listener.Close()
 
@@ -144,7 +145,8 @@ func TestWaitForMappedPortSucceeds(t *testing.T) {
 }
 
 func TestWaitForExposedPortSkipChecksSucceeds(t *testing.T) {
-	listener, err := net.Listen("tcp", "localhost:0")
+	ln := &net.ListenConfig{}
+	listener, err := ln.Listen(t.Context(), "tcp", "localhost:0")
 	require.NoError(t, err)
 	defer listener.Close()
 
@@ -382,7 +384,8 @@ func TestHostPortStrategyFailsWhileExternalCheckingDueToUnexpectedContainerStatu
 }
 
 func TestHostPortStrategyFailsWhileInternalCheckingDueToOOMKilledContainer(t *testing.T) {
-	listener, err := net.Listen("tcp", "localhost:0")
+	ln := &net.ListenConfig{}
+	listener, err := ln.Listen(t.Context(), "tcp", "localhost:0")
 	require.NoError(t, err)
 	defer listener.Close()
 
@@ -422,7 +425,8 @@ func TestHostPortStrategyFailsWhileInternalCheckingDueToOOMKilledContainer(t *te
 }
 
 func TestHostPortStrategyFailsWhileInternalCheckingDueToExitedContainer(t *testing.T) {
-	listener, err := net.Listen("tcp", "localhost:0")
+	ln := &net.ListenConfig{}
+	listener, err := ln.Listen(t.Context(), "tcp", "localhost:0")
 	require.NoError(t, err)
 	defer listener.Close()
 
@@ -463,7 +467,8 @@ func TestHostPortStrategyFailsWhileInternalCheckingDueToExitedContainer(t *testi
 }
 
 func TestHostPortStrategyFailsWhileInternalCheckingDueToUnexpectedContainerStatus(t *testing.T) {
-	listener, err := net.Listen("tcp", "localhost:0")
+	ln := &net.ListenConfig{}
+	listener, err := ln.Listen(t.Context(), "tcp", "localhost:0")
 	require.NoError(t, err)
 	defer listener.Close()
 
@@ -503,7 +508,8 @@ func TestHostPortStrategyFailsWhileInternalCheckingDueToUnexpectedContainerStatu
 }
 
 func TestHostPortStrategySucceedsGivenShellIsNotInstalled(t *testing.T) {
-	listener, err := net.Listen("tcp", "localhost:0")
+	ln := &net.ListenConfig{}
+	listener, err := ln.Listen(t.Context(), "tcp", "localhost:0")
 	require.NoError(t, err)
 	defer listener.Close()
 
@@ -566,7 +572,8 @@ func TestHostPortStrategySucceedsGivenShellIsNotInstalled(t *testing.T) {
 }
 
 func TestHostPortStrategySucceedsGivenShellIsNotFound(t *testing.T) {
-	listener, err := net.Listen("tcp", "localhost:0")
+	ln := &net.ListenConfig{}
+	listener, err := ln.Listen(t.Context(), "tcp", "localhost:0")
 	require.NoError(t, err)
 	defer listener.Close()
 
diff --git a/wait/http_test.go b/wait/http_test.go
index a8aeb3d86d..b40d57471d 100644
--- a/wait/http_test.go
+++ b/wait/http_test.go
@@ -226,15 +226,16 @@ func TestHTTPStrategyWaitUntilReady(t *testing.T) {
 			WithMethod(http.MethodPost).WithBody(bytes.NewReader([]byte("ping"))),
 		),
 	}
+	ctx := t.Context()
 
-	ctr, err := testcontainers.Run(context.Background(), "", opts...)
+	ctr, err := testcontainers.Run(ctx, "", opts...)
 	testcontainers.CleanupContainer(t, ctr)
 	require.NoError(t, err)
 
-	host, err := ctr.Host(context.Background())
+	host, err := ctr.Host(ctx)
 	require.NoError(t, err)
 
-	port, err := ctr.MappedPort(context.Background(), "6443/tcp")
+	port, err := ctr.MappedPort(ctx, "6443/tcp")
 	require.NoError(t, err)
 
 	client := http.Client{
@@ -253,7 +254,11 @@ func TestHTTPStrategyWaitUntilReady(t *testing.T) {
 			ExpectContinueTimeout: 1 * time.Second,
 		},
 	}
-	resp, err := client.Get(fmt.Sprintf("https://%s:%s", host, port.Port()))
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, fmt.Sprintf("https://%s:%s", host, port.Port()), http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := client.Do(req)
 	require.NoError(t, err)
 
 	defer resp.Body.Close()
@@ -277,15 +282,16 @@ func TestHTTPStrategyWaitUntilReadyWithQueryString(t *testing.T) {
 				return bytes.Equal(data, []byte("pong"))
 			})),
 	}
+	ctx := t.Context()
 
-	ctr, err := testcontainers.Run(context.Background(), "", opts...)
+	ctr, err := testcontainers.Run(ctx, "", opts...)
 	testcontainers.CleanupContainer(t, ctr)
 	require.NoError(t, err)
 
-	host, err := ctr.Host(context.Background())
+	host, err := ctr.Host(ctx)
 	require.NoError(t, err)
 
-	port, err := ctr.MappedPort(context.Background(), "6443/tcp")
+	port, err := ctr.MappedPort(ctx, "6443/tcp")
 	require.NoError(t, err)
 
 	client := http.Client{
@@ -304,7 +310,10 @@ func TestHTTPStrategyWaitUntilReadyWithQueryString(t *testing.T) {
 			ExpectContinueTimeout: 1 * time.Second,
 		},
 	}
-	resp, err := client.Get(fmt.Sprintf("https://%s:%s", host, port.Port()))
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, fmt.Sprintf("https://%s:%s", host, port.Port()), http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := client.Do(req)
 	require.NoError(t, err)
 
 	defer resp.Body.Close()
@@ -338,7 +347,7 @@ func TestHTTPStrategyWaitUntilReadyNoBasicAuth(t *testing.T) {
 	}
 	// }
 
-	ctx := context.Background()
+	ctx := t.Context()
 	ctr, err := testcontainers.Run(ctx, "", opts...)
 	testcontainers.CleanupContainer(t, ctr)
 	require.NoError(t, err)
@@ -365,7 +374,10 @@ func TestHTTPStrategyWaitUntilReadyNoBasicAuth(t *testing.T) {
 			ExpectContinueTimeout: 1 * time.Second,
 		},
 	}
-	resp, err := client.Get(fmt.Sprintf("https://%s:%s", host, port.Port()))
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, fmt.Sprintf("https://%s:%s", host, port.Port()), http.NoBody)
+	require.NoError(t, err)
+
+	resp, err := client.Do(req)
 	require.NoError(t, err)
 
 	defer resp.Body.Close()