aws on Grafana Labs

AWSConfig

Mon, 21 Sep 2026 15:16:28 +0000

AWSConfig

AWSConfig is used to configure an AWS service client instance, such as S3Client or SecretsManagerClient. It effectively allows the user to select a region they wish to interact with, and the AWS credentials they wish to use to authenticate.

AWSConfig is included in the aws.js bundle, which includes all the content of the library. It is also included in the various services clients dedicated bundles such as s3.js and secrets-manager.js.

It takes an options object as its single parameter, with the following properties:

Property	Type	Description
region	string	the AWS region to connect to. As described by Amazon AWS docs
accessKeyID	string	The AWS access key ID credential to use for authentication.
secretAccessKey	string	The AWS secret access credential to use for authentication.
sessionToken (optional)	string	The AWS secret access token to use for authentication.
endpoint (optional)	string	The AWS endpoint. Useful for local testing.

Methods

Name	Description
`fromEnvironment()`	Creates an `AWSConfig` using the `AWS_REGION`, `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` and `AWS_SESSION_TOKEN` environment variables.

Throws

S3 Client methods will throw errors in case of failure.

Error	Condition
InvalidArgumentException	when an invalid region name or credentials were used.

Example

An example showing how you can use k6 to instantiate an AWSConfig object and use it to configure a SecretsManagerClient instance.

import exec from 'k6/execution';

// Note that you AWSConfig is also included in the dedicated service
// client bundles such as `s3.js` and `secrets-manager.js`
import {
  AWSConfig,
  SecretsManagerClient,
} from 'https://jslib.k6.io/aws/0.14.0/aws.js';

const awsConfig = new AWSConfig({
  region: __ENV.AWS_REGION,
  accessKeyId: __ENV.AWS_ACCESS_KEY_ID,
  secretAccessKey: __ENV.AWS_SECRET_ACCESS_KEY,
});

const secretsManager = new SecretsManagerClient(awsConfig);

export default function () {
  // ...
}

EventBridgeClient

Mon, 21 Sep 2026 15:16:28 +0000

EventBridgeClient

EventBridgeClient interacts with the AWS EventBridge service.

With it, you can send custom events to Amazon EventBridge. These events can then be matched to rules defined in EventBridge. For a full list of supported operations, see Methods.

Both the dedicated event-bridge.js jslib bundle and the all-encompassing aws.js bundle include the EventBridgeClient.

Methods

Function	Description
putEvents(input)	Send custom events to Amazon EventBridge.

Throws

EventBridgeClient methods will throw errors in case of failure.

Error	Condition
InvalidSignatureError	when invalid credentials were provided or the request signature is invalid.
EventBridgeServiceError	when AWS replied to the requested operation with an error.

Examples

import {
  AWSConfig,
  EventBridgeClient,
} from 'https://jslib.k6.io/aws/0.14.0/event-bridge.js';

const awsConfig = new AWSConfig({
  region: __ENV.AWS_REGION,
  accessKeyId: __ENV.AWS_ACCESS_KEY_ID,
  secretAccessKey: __ENV.AWS_SECRET_ACCESS_KEY,
  sessionToken: __ENV.AWS_SESSION_TOKEN,
});

const eventBridge = new EventBridgeClient(awsConfig);

export default async function () {
  const eventDetails = {
    Source: 'my.custom.source',
    Detail: { key1: 'value1', key2: 'value2' },
    DetailType: 'MyDetailType',
    Resources: ['arn:aws:resource1'],
  };

  const input = {
    Entries: [eventDetails],
  };

  try {
    await eventBridge.putEvents(input);
  } catch (error) {
    console.error(`Failed to put events: ${error.message}`);
  }
}

KinesisClient

Mon, 21 Sep 2026 15:16:28 +0000

KinesisClient

Caution
In some cases, using this library's operations might impact performance and skew your test results.

To ensure accurate results, consider executing these operations in the setup and teardown lifecycle functions. These functions run before and after the test run and have no impact on the test results.

KinesisClient interacts with the AWS Kinesis service.

With it, you can perform operations such as creating streams, putting records, listing streams, and reading records from streams. For a full list of supported operations, see Methods.

Both the dedicated kinesis.js jslib bundle and the all-encompassing aws.js bundle include the KinesisClient.

Methods

Function	Description
createStream(streamName, [options])	Create a new Kinesis stream
deleteStream(streamName)	Delete a Kinesis stream
listStreams([options])	List available Kinesis streams
putRecords(streamName, records)	Put multiple records into a Kinesis stream
getRecords(shardIterator, [options])	Get records from a Kinesis stream shard
listShards(streamName, [options])	List shards in a Kinesis stream
getShardIterator(streamName, shardId, shardIteratorType, [options])	Get a shard iterator for reading records from a stream

Throws

KinesisClient methods will throw errors in case of failure.

Error	Condition
InvalidSignatureError	When invalid credentials are provided.
KinesisServiceError	When AWS replies to the requested operation with an error.

Examples

import { check } from 'k6';
import exec from 'k6/execution';

import {
  AWSConfig,
  KinesisClient,
} from 'https://jslib.k6.io/aws/0.14.0/kinesis.js';

const awsConfig = new AWSConfig({
  region: __ENV.AWS_REGION,
  accessKeyId: __ENV.AWS_ACCESS_KEY_ID,
  secretAccessKey: __ENV.AWS_SECRET_ACCESS_KEY,
});

const kinesis = new KinesisClient(awsConfig);
const testStreamName = 'test-stream';

export default async function () {
  // List available streams
  const streams = await kinesis.listStreams();
  console.log('Available streams:', streams.streamNames);

  // Check if our test stream exists
  if (!streams.streamNames.includes(testStreamName)) {
    // Create the stream if it doesn't exist
    await kinesis.createStream(testStreamName, { shardCount: 1 });
    console.log(`Created stream: ${testStreamName}`);
  }

  // Put some records into the stream
  const records = [
    {
      data: JSON.stringify({ message: 'Hello from k6!', timestamp: Date.now() }),
      partitionKey: 'test-partition-1',
    },
    {
      data: JSON.stringify({ message: 'Another message', timestamp: Date.now() }),
      partitionKey: 'test-partition-2',
    },
  ];

  const putResult = await kinesis.putRecords(testStreamName, records);
  console.log('Put records result:', putResult);

  // List shards in the stream
  const shards = await kinesis.listShards(testStreamName);
  console.log('Stream shards:', shards.shards);

  // Get a shard iterator for reading records
  if (shards.shards.length > 0) {
    const shardId = shards.shards[0].shardId;
    const shardIterator = await kinesis.getShardIterator(testStreamName, shardId, 'TRIM_HORIZON');

    // Get records from the shard
    const getResult = await kinesis.getRecords(shardIterator.shardIterator);
    console.log('Retrieved records:', getResult.records);
  }
}

Stream management

import {
  AWSConfig,
  KinesisClient,
} from 'https://jslib.k6.io/aws/0.14.0/kinesis.js';

const awsConfig = new AWSConfig({
  region: __ENV.AWS_REGION,
  accessKeyId: __ENV.AWS_ACCESS_KEY_ID,
  secretAccessKey: __ENV.AWS_SECRET_ACCESS_KEY,
});

const kinesis = new KinesisClient(awsConfig);

export default async function () {
  const streamName = 'my-test-stream';

  // Create a stream with on-demand billing
  await kinesis.createStream(streamName, {
    streamModeDetails: {
      streamMode: 'ON_DEMAND',
    },
  });

  // List all streams
  const streams = await kinesis.listStreams();
  console.log('All streams:', streams.streamNames);

  // Clean up - delete the stream
  await kinesis.deleteStream(streamName);
  console.log(`Deleted stream: ${streamName}`);
}

KMSClient

Mon, 21 Sep 2026 15:16:28 +0000

KMSClient

Caution
In some cases, using this library's operations might impact performance and skew your test results.

To ensure accurate results, consider executing these operations in the setup and teardown lifecycle functions. These functions run before and after the test run and have no impact on the test results.

KMSClient interacts with the AWS Key Management Service.

With it, the user can list all the Key Management Service keys in the caller’s AWS account and region. They can also generate symmetric data keys to use outside of AWS Key Management Service.

Both the dedicated kms.js jslib bundle and the all-encompassing aws.js bundle include the KMSClient.

Methods

Function	Description
listKeys	List the all the Key Management Service keys in the caller’s AWS account and region.
generateDataKey	Generate a symmetric data key for use outside of the AWS Key Management Service.

Throws

KMSClient methods throw errors in case of failure.

Error	Condition
`InvalidSignatureError`	when using invalid credentials
`KMSServiceError`	when AWS replied to the requested operation with an error

Example

import { textSummary } from 'https://jslib.k6.io/k6-summary/0.0.2/index.js';

import {
  AWSConfig,
  KMSClient,
} from 'https://jslib.k6.io/aws/0.14.0/kms.js';

const awsConfig = new AWSConfig({
  region: __ENV.AWS_REGION,
  accessKeyId: __ENV.AWS_ACCESS_KEY_ID,
  secretAccessKey: __ENV.AWS_SECRET_ACCESS_KEY,
});

const kms = new KMSClient(awsConfig);
const keyAlias = 'alias/k6-key';

export async function setup() {
  // Create a symmetric data key
  return {
    dataKey: await kms.generateDataKey(keyAlias, 32),
  };
}

export default async function (data) {
  // Use the data key to encrypt data
}

export function handleSummary(data) {
  return {
    'stdout': textSummary(data, { indent: ' ', enableColors: true }),
    './test-run.key': data.dataKey,
  };
}

LambdaClient

Mon, 21 Sep 2026 15:16:28 +0000

LambdaClient

Caution
In some cases, using this library's operations might impact performance and skew your test results.

To ensure accurate results, consider executing these operations in the setup and teardown lifecycle functions. These functions run before and after the test run and have no impact on the test results.

LambdaClient interacts with AWS Lambda. With it, you can invoke a Lambda function.

Both the dedicated lambda.js jslib bundle and the all-encompassing aws.js bundle include the LambdaClient.

Methods

Function	Description
invoke(name, payload, [options])	Invokes an AWS Lambda function.

Throws

LambdaClient methods will throw errors in case of failure.

Error	Condition
InvalidSignatureError	When invalid credentials were provided.
LambdaInvocationError	When AWS replied to the requested invocation with an error.

Examples

import {
  AWSConfig,
  LambdaClient,
} from 'https://jslib.k6.io/aws/0.14.0/lambda.js';
import { check } from 'k6';

const awsConfig = new AWSConfig({
  region: __ENV.AWS_REGION,
  accessKeyId: __ENV.AWS_ACCESS_KEY_ID,
  secretAccessKey: __ENV.AWS_SECRET_ACCESS_KEY,
  sessionToken: __ENV.AWS_SESSION_TOKEN,
});

const lambdaClient = new LambdaClient(awsConfig);

export default async function () {
  const response = await lambdaClient.invoke('add-numbers', JSON.stringify({ x: 1, y: 2 }));

  check(response, {
    'status is 200': (r) => r.statusCode === 200,
    'payload is 3': (r) => r.payload === 3,
  });
}

S3Client

Mon, 21 Sep 2026 15:16:28 +0000

S3Client

Caution
In some cases, using this library's operations might impact performance and skew your test results.

To ensure accurate results, consider executing these operations in the setup and teardown lifecycle functions. These functions run before and after the test run and have no impact on the test results.

S3Client interacts with the AWS Simple Storage Service (S3).

With it, you can do several operations such as list buckets, list objects in a bucket, or download objects from a bucket. For a full list of supported operations, see Methods.

Both the dedicated s3.js jslib bundle and the all-encompassing aws.js bundle include the S3Client.

Methods

Function	Description
listBuckets()	List the buckets the authenticated user has access to
listObjects(bucketName, [prefix])	List the objects contained in a bucket
getObject(bucketName, objectKey)	Download an object from a bucket
putObject(bucketName, objectKey, data)	Upload an object to a bucket
deleteObject(bucketName, objectKey)	Delete an object from a bucket
copyObject(sourceBucket, sourceKey, destinationBucket, destinationKey)	Copy an object from one bucket to another
createMultipartUpload(bucketName, objectKey)	Create a multipart upload for a given objectKey to a bucket
uploadPart(bucketName, objectKey, uploadId, partNumber, data)	Upload a part in a multipart upload
completeMultipartUpload(bucketName, objectKey, uploadId, parts)	Complete a previously assembled multipart upload
abortMultipartUpload(bucketName, objectKey, uploadId)	Abort a multipart upload

Throws

S3 Client methods will throw errors in case of failure.

Error	Condition
InvalidSignatureError	when invalid credentials were provided.
S3ServiceError	when AWS replied to the requested operation with an error.

Examples

import { check } from 'k6';
import exec from 'k6/execution';
import http from 'k6/http';

import {
  AWSConfig,
  S3Client,
} from 'https://jslib.k6.io/aws/0.14.0/s3.js';

const awsConfig = new AWSConfig({
  region: __ENV.AWS_REGION,
  accessKeyId: __ENV.AWS_ACCESS_KEY_ID,
  secretAccessKey: __ENV.AWS_SECRET_ACCESS_KEY,
});

const s3 = new S3Client(awsConfig);
const testBucketName = 'test-jslib-aws';
const testInputFileKey = 'productIDs.json';
const testOutputFileKey = `results-${Date.now()}.json`;

export async function setup() {
  // If our test bucket does not exist, abort the execution.
  const buckets = await s3.listBuckets();
  if (buckets.filter((b) => b.name === testBucketName).length == 0) {
    exec.test.abort();
  }

  // If our test object does not exist, abort the execution.
  const objects = await s3.listObjects(testBucketName);
  if (objects.filter((o) => o.key === testInputFileKey).length == 0) {
    exec.test.abort();
  }

  // Download the S3 object containing our test data
  const inputObject = await s3.getObject(testBucketName, testInputFileKey);

  // Let's return the downloaded S3 object's data from the
  // setup function to allow the default function to use it.
  return {
    productIDs: JSON.parse(inputObject.data),
  };
}

export default async function (data) {
  // Pick a random product ID from our test data
  const randomProductID = data.productIDs[Math.floor(Math.random() * data.productIDs.length)];

  // Query our ecommerce website's product page using the ID
  const res = await http.asyncRequest('GET', `http://your.website.com/product/${randomProductID}/`);
  check(res, { 'is status 200': res.status === 200 });
}

export async function handleSummary(data) {
  // Once the load test is over, let's upload the results to our
  // S3 bucket. This is executed after teardown.
  await s3.putObject(testBucketName, testOutputFileKey, JSON.stringify(data));
}

Multipart uploads

import crypto from 'k6/crypto';
import exec from 'k6/execution';

import {
  AWSConfig,
  S3Client,
} from 'https://jslib.k6.io/aws/0.14.0/s3.js';

const awsConfig = new AWSConfig({
  region: __ENV.AWS_REGION,
  accessKeyId: __ENV.AWS_ACCESS_KEY_ID,
  secretAccessKey: __ENV.AWS_SECRET_ACCESS_KEY,
  sessionToken: __ENV.AWS_SESSION_TOKEN,
});

const s3 = new S3Client(awsConfig);

const testBucketName = 'test-jslib-aws';
const testFileKey = 'multipart.txt';

export default async function () {
  // List the buckets the AWS authentication configuration
  // gives us access to.
  const buckets = await s3.listBuckets();

  // If our test bucket does not exist, abort the execution.
  if (buckets.filter((b) => b.name === testBucketName).length == 0) {
    exec.test.abort();
  }

  // Produce random bytes to upload of size ~12MB, that
  // we will upload in two 6MB parts. This is done as the
  // minimum part size supported by S3 is 5MB.
  const bigFile = crypto.randomBytes(12 * 1024 * 1024);

  // Initialize a multipart upload
  const multipartUpload = await s3.createMultipartUpload(testBucketName, testFileKey);

  // Upload the first part
  const firstPartData = bigFile.slice(0, 6 * 1024 * 1024);
  const firstPart = await s3.uploadPart(
    testBucketName,
    testFileKey,
    multipartUpload.uploadId,
    1,
    firstPartData
  );

  // Upload the second part
  const secondPartData = bigFile.slice(6 * 1024 * 1024, 12 * 1024 * 1024);
  const secondPart = await s3.uploadPart(
    testBucketName,
    testFileKey,
    multipartUpload.uploadId,
    2,
    secondPartData
  );

  // Complete the multipart upload
  await s3.completeMultipartUpload(testBucketName, testFileKey, multipartUpload.uploadId, [
    firstPart,
    secondPart,
  ]);

  // Let's redownload it verify it's correct, and delete it
  const obj = await s3.getObject(testBucketName, testFileKey);
  await s3.deleteObject(testBucketName, testFileKey);
}

SecretsManagerClient

Mon, 21 Sep 2026 15:16:28 +0000

SecretsManagerClient

SecretsManagerClient interacts with the AWS Secrets Manager.

With it, you can perform several operations such as listing, creating and downloading secrets owned by the authenticated user. For a full list of supported operations, see Methods.

SecretsManagerClient is included in both the dedicated jslib secrets-manager.js bundle, and the aws.js one, containing all the services clients.

Methods

Function	Description
listSecrets()	List secrets owned by the authenticated user
getSecret(secretID)	Download a secret
createSecret(name, secretString, description, [versionID], [tags])	Create a new secret
putSecretValue(secretID, secretString, [versionID])	Update a secret
deleteSecret(secretID, { recoveryWindow: 30, noRecovery: false}})	Delete a secret

Throws

S3 Client methods will throw errors in case of failure.

Error	Condition
InvalidSignatureError	when invalid credentials were provided.
SecretsManagerServiceError	when AWS replied to the requested operation with an error.

Example

import exec from 'k6/execution';

import {
  AWSConfig,
  SecretsManagerClient,
} from 'https://jslib.k6.io/aws/0.14.0/secrets-manager.js';

const awsConfig = new AWSConfig({
  region: __ENV.AWS_REGION,
  accessKeyId: __ENV.AWS_ACCESS_KEY_ID,
  secretAccessKey: __ENV.AWS_SECRET_ACCESS_KEY,
});

const secretsManager = new SecretsManagerClient(awsConfig);
const testSecretName = 'jslib-test-secret';
const testSecretValue = 'jslib-test-value';

export async function setup() {
  // Let's make sure our test secret is created
  const testSecret = await secretsManager.createSecret(
    testSecretName,
    testSecretValue,
    'this is a test secret, delete me.'
  );

  // List the secrets the AWS authentication configuration
  // gives us access to, and verify the creation was successful.
  const secrets = await secretsManager.listSecrets();
  if (!secrets.filter((s) => s.name === testSecret.name).length == 0) {
    exec.test.abort('test secret not found');
  }
}

export default async function () {
  // Knnowing that we know the secret exist, let's update its value
  const newTestSecretValue = 'new-test-value';
  await secretsManager.putSecretValue(testSecretName, newTestSecretValue);

  // Let's get its value and verify it was indeed updated
  const updatedSecret = await secretsManager.getSecret(testSecretName);
  if (updatedSecret.secret !== newTestSecretValue) {
    exec.test.abort('unable to update test secret');
  }

  // Let's now use our secret in the context of our load test...
}

export async function teardown() {
  // Finally, let's clean after ourselves and delete our test secret
  await secretsManager.deleteSecret(testSecretName, { noRecovery: true });
}

SignatureV4

Mon, 21 Sep 2026 15:16:28 +0000

SignatureV4

Caution
In some cases, using this library's operations might impact performance and skew your test results.

To ensure accurate results, consider executing these operations in the setup and teardown lifecycle functions. These functions run before and after the test run and have no impact on the test results.

With SignatureV4, you can produce authenticated HTTP requests to AWS services. Namely, it lets you sign and pre-sign requests to AWS services using the Signature V4 algorithm. The sign operation produces a signed request with authorization information stored in its headers. The presign operation produces a pre-signed request with authorization information stored in its query string parameters.

SignatureV4 is included in both the dedicated jslib signature.js bundle and the aws.js one, containing all the service’s clients.

Instantiating a new SignatureV4 requires a single options object argument with the following properties:

Property	Type	Description
service	string	the AWS region to sign or pre-sign requests for. As described by Amazon AWS docs
region	string	the AWS service to sign or pre-sign requests for. As described by Amazon AWS docs]
credentials	an object with `accessKeyId`, `secretAccessKey`, and optional `sessionToken` properties	the AWS credentials to sign or pre-sign requests with.
uriEscapePath	boolean	Whether to uri-escape the request URI path as part of computing the canonical request string. As of late 2017, this is required for every AWS service except Amazon S3.
applyChecksum	boolean	Whether to calculate a checksum of the request body and include it as either a request header (when signing) or as a query string parameter (when pre-signing). This is required for AWS Glacier and Amazon S3 and optional for every other AWS service as of late 2017.

Methods

Method	Description
sign()	Signs an authenticated HTTP request using the AWS signature v4 algorithm
presign()	Produces an authenticated pre-signed URL using the AWS signature v4 algorithm

Throws

SignatureV4 methods throw errors on failure.

Error	Condition
InvalidSignatureError	when invalid credentials were provided.

Example

import http from 'k6/http';

import {
  AWSConfig,
  Endpoint,
  SignatureV4,
} from 'https://jslib.k6.io/aws/0.14.0/signature.js';

const awsConfig = new AWSConfig({
  region: __ENV.AWS_REGION,
  accessKeyId: __ENV.AWS_ACCESS_KEY_ID,
  secretAccessKey: __ENV.AWS_SECRET_ACCESS_KEY,
  sessionToken: __ENV.AWS_SESSION_TOKEN,
});

export default function () {
  /**
   * In order to be able to sign an HTTP request's,
   * we need to instantiate a SignatureV4 object.
   */
  const signer = new SignatureV4({
    service: 's3',
    region: awsConfig.region,
    credentials: {
      accessKeyId: awsConfig.accessKeyId,
      secretAccessKey: awsConfig.secretAccessKey,
      sessionToken: awsConfig.sessionToken,
    },

    /**
     * Whether the URI should be escaped or not.
     */
    uriEscapePath: false,

    /**
     * Whether or not the body's hash should be calculated and included
     * in the request.
     */
    applyChecksum: true,
  });

  /**
   * The sign operation will return a new HTTP request with the
   * AWS signature v4 protocol headers added. It returns an Object
   * implementing the SignedHTTPRequest interface, holding a `url` and a `headers`
   * properties, ready to use in the context of k6's http call.
   */
  const signedRequest = signer.sign(
    /**
     * HTTP request description
     */
    {
      /**
       * The HTTP method we will use in the request.
       */
      method: 'GET',

      /**
       * The endpoint of the service we will be making the request to.
       *
       * The endpoint is instantiated from a URL string, of the format: `{scheme}://{hostname}[:{port}]`
       */
      endpoint: new Endpoint('https://s3.us-east-1.amazonaws.com'),

      /**
       * The path of the request.
       */
      path: '/my-bucket/bonjour.txt',

      /**
       * The query parameters to include in the request.
       */
      query: {
        'abc': '123',
        'easy as': ['do', 're', 'mi'],
      },

      /**
       * The headers we will be sending in the request.
       */
      headers: {},

      /**
       * The body of the request.
       */
      body: null,
    },

    /**
     * (optional) Signature operation options allows to override the
     * SignatureV4's options in the context of this specific request.
     */
    {
      /**
       * The date and time to be used as signature metadata. This value should be
       * a Date object, a unix (epoch) timestamp, or a string that can be
       * understood by the JavaScript `Date` constructor.If not supplied, the
       * value returned by `new Date()` will be used.
       */
      signingDate: new Date(),

      /**
       * The service signing name. It will override the service name of the signer
       * in current invocation
       */
      signingService: 's3',

      /**
       * The region name to sign the request. It will override the signing region of the
       * signer in current invocation
       */
      signingRegion: 'us-east-1',
    }
  );

  http.get(signedRequest.url, { headers: signedRequest.headers });
}

SQSClient

Mon, 21 Sep 2026 15:16:28 +0000

SQSClient

SQSClient interacts with the AWS Simple Queue Service (SQS).

With it, the user can send messages to specified queues, receive messages from queues, delete processed messages, and list available queues in the current region.

SQSClient is included in both the dedicated sqs.js jslib bundle and the all-encompassing aws.js one, containing all the services clients.

Methods

Function	Description
sendMessage	Delivers a message to the specified queue.
sendMessageBatch	Delivers up to ten messages to the specified queue.
receiveMessages	Receives messages from the specified queue.
deleteMessage	Deletes a message from the specified queue.
listQueues	Returns a list of your queues in the current region.

Throws

SQSClient methods throw errors in case of failure.

Error	Condition
`InvalidSignatureError`	when using invalid credentials
`SQSServiceError`	when AWS replied to the requested operation with an error

Example

import exec from 'k6/execution';

import {
  AWSConfig,
  SQSClient,
} from 'https://jslib.k6.io/aws/0.14.0/sqs.js';

const awsConfig = new AWSConfig({
  region: __ENV.AWS_REGION,
  accessKeyId: __ENV.AWS_ACCESS_KEY_ID,
  secretAccessKey: __ENV.AWS_SECRET_ACCESS_KEY,
  sessionToken: __ENV.AWS_SESSION_TOKEN,
});

const sqs = new SQSClient(awsConfig);
const testQueue = 'https://sqs.us-east-1.amazonaws.com/000000000/test-queue';

export default async function () {
  // If our test queue does not exist, abort the execution.
  const queuesResponse = await sqs.listQueues();
  if (queuesResponse.urls.filter((q) => q === testQueue).length == 0) {
    exec.test.abort();
  }

  // Send message to test queue
  await sqs.sendMessage(testQueue, JSON.stringify({ value: '123' }));

  // Receive messages from the queue
  const messages = await sqs.receiveMessages(testQueue, {
    maxNumberOfMessages: 10,
    waitTimeSeconds: 2,
  });

  // Process and delete each received message
  for (const message of messages) {
    console.log('Processing message:', message.body);

    // Delete the message after processing
    await sqs.deleteMessage(testQueue, message.receiptHandle);
  }
}

SystemsManagerClient

Mon, 21 Sep 2026 15:16:28 +0000

SystemsManagerClient

SystemsManagerClient interacts with the AWS Systems Manager Service.

With it, the user can get parameters from the Systems Manager Service in the caller’s AWS account and region.

Both the dedicated ssm.js jslib bundle and the all-encompassing aws.js bundle include the SystemsManagerClient.

Methods

Function	Description
getParameter	Retrieves a parameter from Amazon Systems Manager.

Throws

SystemsManagerClient methods throw errors in case of failure.

Error	Condition
`InvalidSignatureError`	when using invalid credentials
`SystemsManagerServiceError`	when AWS replied to the requested operation with an error

Example

import exec from 'k6/execution';

import {
  AWSConfig,
  SystemsManagerClient,
} from 'https://jslib.k6.io/aws/0.14.0/ssm.js';

const awsConfig = new AWSConfig({
  region: __ENV.AWS_REGION,
  accessKeyId: __ENV.AWS_ACCESS_KEY_ID,
  secretAccessKey: __ENV.AWS_SECRET_ACCESS_KEY,
  sessionToken: __ENV.AWS_SESSION_TOKEN,
});

const systemsManager = new SystemsManagerClient(awsConfig);
const testParameterName = 'jslib-test-parameter';
const testParameterValue = 'jslib-test-value';
const testParameterSecretName = 'jslib-test-parameter-secret';
// this value was created with --type SecureString
const testParameterSecretValue = 'jslib-test-secret-value';

export default async function () {
  // Currently the parameter needs to be created before hand

  // Let's get its value
  // getParameter returns a parameter object: e.g. {name: string, value: string...}
  const parameter = await systemsManager.getParameter(testParameterName);
  if (parameter.value !== testParameterValue) {
    exec.test.abort('test parameter not found');
  }

  // Let's get the secret value with decryption
  // destructure the parameter object to get to the values you want
  const { value: encryptedParameterValue } = await systemsManager.getParameter(
    testParameterSecretName,
    true
  );
  if (encryptedParameterValue !== testParameterSecretValue) {
    exec.test.abort('encrypted test parameter not found');
  }
}

A k6 script querying a user’s Systems Manager Service parameter