LocalStack¶

Since testcontainers-go v0.18.0

Introduction¶

The Testcontainers module for LocalStack is "a fully functional local AWS cloud stack", to develop and test your cloud and serverless apps without actually using the cloud.

Adding this module to your project dependencies¶

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

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

Usage example¶

Running LocalStack as a stand-in for multiple AWS services during a test:

Creating a LocalStack container

container, err := localstack.RunContainer(ctx)
require.Nil(t, err)

Environment variables listed in Localstack's README may be used to customize Localstack's configuration. Use the OverrideContainerRequest option when creating the LocalStackContainer to apply configuration settings.

Creating a client using the AWS SDK for Go¶

Version 1¶

Test for a LocalStack container, usinv AWS SDK v1

// awsSession returns a new AWS session for the given service. To retrieve the specific AWS service client, use the
// session's client method, e.g. s3manager.NewUploader(session).
func awsSession(ctx context.Context, l *localstack.LocalStackContainer) (*session.Session, error) {
    mappedPort, err := l.MappedPort(ctx, nat.Port("4566/tcp"))
    if err != nil {
        return &session.Session{}, err
    }

    provider, err := testcontainers.NewDockerProvider()
    if err != nil {
        return &session.Session{}, err
    }
    defer provider.Close()

    host, err := provider.DaemonHost(ctx)
    if err != nil {
        return &session.Session{}, err
    }

    awsConfig := &aws.Config{
        Region:                        aws.String(region),
        CredentialsChainVerboseErrors: aws.Bool(true),
        Credentials:                   credentials.NewStaticCredentials(accesskey, secretkey, token),
        S3ForcePathStyle:              aws.Bool(true),
        Endpoint:                      aws.String(fmt.Sprintf("http://%s:%d", host, mappedPort.Int())),
    }

    return session.NewSession(awsConfig)
}

For further reference on the SDK v1, please check out the AWS docs here.

Version 2¶

Test for a LocalStack container, usinv AWS SDK v2

func s3Client(ctx context.Context, l *localstack.LocalStackContainer) (*s3.Client, error) {
    mappedPort, err := l.MappedPort(ctx, nat.Port("4566/tcp"))
    if err != nil {
        return nil, err
    }

    provider, err := testcontainers.NewDockerProvider()
    if err != nil {
        return nil, err
    }
    defer provider.Close()

    host, err := provider.DaemonHost(ctx)
    if err != nil {
        return nil, err
    }

    customResolver := aws.EndpointResolverWithOptionsFunc(
        func(service, region string, opts ...interface{}) (aws.Endpoint, error) {
            return aws.Endpoint{
                PartitionID:   "aws",
                URL:           fmt.Sprintf("http://%s:%d", host, mappedPort.Int()),
                SigningRegion: region,
            }, nil
        })

    awsCfg, err := config.LoadDefaultConfig(context.TODO(),
        config.WithRegion(region),
        config.WithEndpointResolverWithOptions(customResolver),
        config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(accesskey, secretkey, token)),
    )
    if err != nil {
        return nil, err
    }

    client := s3.NewFromConfig(awsCfg, func(o *s3.Options) {
        o.UsePathStyle = true
    })

    return client, nil
}

For further reference on the SDK v2, please check out the AWS docs here

Accessing hostname-sensitive services¶

Some Localstack APIs, such as SQS, require the container to be aware of the hostname that it is accessible on - for example, for construction of queue URLs in responses.

Testcontainers will inform Localstack of the best hostname automatically, using the an environment variable for that:

for Localstack versions 0.10.0 and above, the HOSTNAME_EXTERNAL environment variable will be set to hostname in the container request.
for Localstack versions 2.0.0 and above, the LOCALSTACK_HOST environment variable will be set to the hostname in the container request.

Once the variable is set:

when running the Localstack container directly without a custom network defined, it is expected that all calls to the container will be from the test host. As such, the container address will be used (typically localhost or the address where the Docker daemon is running).

Localstack container running without a custom network
```
container, err := StartContainer(
    ctx,
    OverrideContainerRequest(testcontainers.ContainerRequest{
        Image: fmt.Sprintf("localstack/localstack:%s", "2.0.0"),
    }),
)
```

when running the Localstack container with a custom network defined, it is expected that all calls to the container will be from other containers on that network. HOSTNAME_EXTERNAL will be set to the last network alias that has been configured for the Localstack container.

Localstack container running with a custom network

ctx := context.Background()

nw, err := testcontainers.GenericNetwork(ctx, testcontainers.GenericNetworkRequest{
    NetworkRequest: testcontainers.NetworkRequest{
        Name: "localstack-network",
    },
})
require.Nil(t, err)
assert.NotNil(t, nw)

container, err := RunContainer(
    ctx,
    testcontainers.CustomizeRequest(testcontainers.GenericContainerRequest{
        ContainerRequest: testcontainers.ContainerRequest{
            Image:          "localstack/localstack:0.13.0",
            Env:            map[string]string{"SERVICES": "s3,sqs"},
            Networks:       []string{"localstack-network"},
            NetworkAliases: map[string][]string{"localstack-network": {"localstack"}},
        },
    }),
)
require.Nil(t, err)
assert.NotNil(t, container)

Other usage scenarios, such as where the Localstack container is used from both the test host and containers on a custom network are not automatically supported. If you have this use case, you should set HOSTNAME_EXTERNAL manually.

Module reference¶

The LocalStack module exposes one single function to create the LocalStack container, and this function receives two parameters:

func RunContainer(ctx context.Context, opts ...testcontainers.ContainerCustomizer) (*LocalStackContainer, error)

context.Context, the Go context.
testcontainers.ContainerCustomizer, a variadic argument for passing options.

Container Options¶

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

Set Image¶

By default, the image used is localstack:1.4.0. If you need to use a different image, you can use testcontainers.WithImage option.

Custom Image

container, err := RunContainer(
    ctx,
    testcontainers.WithImage(fmt.Sprintf("localstack/localstack:%s", defaultVersion)),
)

Customize the container request¶

It's possible to entirely override the default LocalStack container request:

Customize container request

localstack, err := RunContainer(
    ctx,
    testcontainers.CustomizeRequest(testcontainers.GenericContainerRequest{
        ContainerRequest: testcontainers.ContainerRequest{
            Image:          "localstack/localstack:2.0.0",
            Networks:       []string{"localstack-network-v2"},
            NetworkAliases: map[string][]string{"localstack-network-v2": {"localstack"}},
        },
    }),
)

With simply passing the testcontainers.CustomizeRequest functional option to the RunContainer function, you'll be able to configure the LocalStack container with your own needs, as this new container request will be merged with the original one.

In the following example you check how it's possible to set certain environment variables that are needed by the tests, the most important of them the AWS services you want to use. Besides, the container runs in a separate Docker network with an alias:

Overriding the default container request

ctx := context.Background()

nw, err := testcontainers.GenericNetwork(ctx, testcontainers.GenericNetworkRequest{
    NetworkRequest: testcontainers.NetworkRequest{
        Name: "localstack-network",
    },
})
require.Nil(t, err)
assert.NotNil(t, nw)

container, err := RunContainer(
    ctx,
    testcontainers.CustomizeRequest(testcontainers.GenericContainerRequest{
        ContainerRequest: testcontainers.ContainerRequest{
            Image:          "localstack/localstack:0.13.0",
            Env:            map[string]string{"SERVICES": "s3,sqs"},
            Networks:       []string{"localstack-network"},
            NetworkAliases: map[string][]string{"localstack-network": {"localstack"}},
        },
    }),
)
require.Nil(t, err)
assert.NotNil(t, container)

If you do not need to override the container request, you can simply pass the Go context to the RunContainer function.

Skip overriding the default container request

ctx := context.Background()

container, err := RunContainer(ctx)
require.Nil(t, err)
assert.NotNil(t, container)

Testing the module¶

The module includes unit and integration tests that can be run from its source code. To run the tests please execute the following command:

cd modules/localstack
make test

Info

At this moment, the tests for the module include tests for the S3 service, only. They live in two different Go packages of the LocalStack module, v1 and v2, where it'll be easier to add more examples for the rest of services.