Skip to content

Socat

Since v0.37.0

Introduction

The Testcontainers module for Socat, a utility container that provides TCP port forwarding and network tunneling between services, enabling transparent communication between containers and networks.

This is particularly useful in testing scenarios where you need to simulate network connections or provide transparent access to services running in different containers.

Adding this module to your project dependencies

Please run the following command to add the Socat module to your Go dependencies:

go get github.com/testcontainers/testcontainers-go/modules/socat

Usage example

nw, err := network.New(ctx)
if err != nil {
    log.Printf("failed to create network: %v", err)
    return
}
defer func() {
    if err := nw.Remove(ctx); err != nil {
        log.Printf("failed to remove network: %s", err)
    }
}()

ctr, err := testcontainers.Run(ctx, "testcontainers/helloworld:1.2.0",
    network.WithNetwork([]string{"helloworld"}, nw),
    testcontainers.WithExposedPorts("8080/tcp"),
)
if err != nil {
    log.Printf("failed to create container: %v", err)
    return
}
defer func() {
    if err := testcontainers.TerminateContainer(ctr); err != nil {
        log.Printf("failed to terminate container: %s", err)
    }
}()

const (
    // The helloworld container is listening on both ports: 8080 and 8081
    port1 = 8080
    port2 = 8081
    // The helloworld container is not listening on these ports,
    // but the socat container will forward the traffic to the correct port
    port3 = 9080
    port4 = 9081
)

targets := []socat.Target{
    socat.NewTarget(port1, "helloworld"),                        // using a default port
    socat.NewTarget(port2, "helloworld"),                        // using a default port
    socat.NewTargetWithInternalPort(port3, port1, "helloworld"), // using a different port
    socat.NewTargetWithInternalPort(port4, port2, "helloworld"), // using a different port
}

socatContainer, err := socat.Run(
    ctx, socat.DefaultImage,
    socat.WithTarget(targets[0]),
    socat.WithTarget(targets[1]),
    socat.WithTarget(targets[2]),
    socat.WithTarget(targets[3]),
    network.WithNetwork([]string{"socat"}, nw),
)
if err != nil {
    log.Printf("failed to create container: %v", err)
    return
}
defer func() {
    if err := testcontainers.TerminateContainer(socatContainer); err != nil {
        log.Printf("failed to terminate container: %s", err)
    }
}()

httpClient := http.DefaultClient

baseURI := socatContainer.TargetURL(target.ExposedPort())

resp, err := httpClient.Get(baseURI.String() + "/ping")
if err != nil {
    log.Printf("failed to get response: %v", err)
    return
}
defer resp.Body.Close()

Module Reference

Run function

The Socat module exposes one entrypoint function to create the Socat container, and this function receives three parameters:

func Run(ctx context.Context, img string, opts ...testcontainers.ContainerCustomizer) (*Container, error)
  • context.Context, the Go context.
  • string, the Docker image to use.
  • testcontainers.ContainerCustomizer, a variadic argument for passing options.

Image

The module exposes a default image:

// DefaultImage is the default image used by the Socat container.
DefaultImage = "alpine/socat:1.8.0.1"

Use the second argument in the Run function to set a valid Docker image. In example: Run(context.Background(), DefaultImage).

Container Options

When starting the Socat container, you can pass options in a variadic way to configure it.

WithTarget

The WithTarget function sets a single target for the Socat container, defined by the Target struct. This struct can be built using the the following functions:

  • NewTarget(exposedPort int, host string): Creates a new target for the Socat container. The target's internal port is set to the same value as the exposed port.
  • NewTargetWithInternalPort(exposedPort int, internalPort int, host string): Creates a new target for the Socat container with an internal port. Use this function when you want to map a container to a different port than the default one.
const (
    // The helloworld container is listening on both ports: 8080 and 8081
    port1 = 8080
    port2 = 8081
    // The helloworld container is not listening on these ports,
    // but the socat container will forward the traffic to the correct port
    port3 = 9080
    port4 = 9081
)

targets := []socat.Target{
    socat.NewTarget(port1, "helloworld"),                        // using a default port
    socat.NewTarget(port2, "helloworld"),                        // using a default port
    socat.NewTargetWithInternalPort(port3, port1, "helloworld"), // using a different port
    socat.NewTargetWithInternalPort(port4, port2, "helloworld"), // using a different port
}

socatContainer, err := socat.Run(
    ctx, socat.DefaultImage,
    socat.WithTarget(targets[0]),
    socat.WithTarget(targets[1]),
    socat.WithTarget(targets[2]),
    socat.WithTarget(targets[3]),
    network.WithNetwork([]string{"socat"}, nw),
)
if err != nil {
    log.Printf("failed to create container: %v", err)
    return
}
defer func() {
    if err := testcontainers.TerminateContainer(socatContainer); err != nil {
        log.Printf("failed to terminate container: %s", err)
    }
}()

In the above example, there is a helloworld container that is listening on port 8080 and 8081. Please check the helloworld container source code for more details.

The following options are exposed by the testcontainers package.

Basic Options

Lifecycle Options

Files & Mounts Options

Build Options

Logging Options

Image Options

Networking Options

Advanced Options

Experimental Options

Container Methods

The Socat container exposes the following methods:

TargetURL

The TargetURL(port int) method returns the URL for the exposed port of a target, nil if the port is not mapped.

httpClient := http.DefaultClient

baseURI := socatContainer.TargetURL(target.ExposedPort())

resp, err := httpClient.Get(baseURI.String() + "/ping")
if err != nil {
    log.Printf("failed to get response: %v", err)
    return
}
defer resp.Body.Close()