Load Testing using K6 in AWS and Terraform

Benson Michael — Fri, 14 Jul 2023 03:21:40 +0000

Summary:

This article talks about how you can deploy your K6 tests in AWS using Terraform and execute them from Gitlab pipeline.

Tools:

K6 load testing framework.
Grafana.
InfluxDB.

Steps:

Build an EC2 instance to run k6 using the following code:

provider "aws" {
  region  = "us-west-2"
  version = "~> 2.8"
}

data "template_file" "user_data" {
  template = file("${path.module}/_templates/k6_data.sh")
}

# The EC2 instance
resource "aws_instance" "k6_instance" {

  ami           = var.ami
  instance_type = var.instance_type
  key_name      = var.key_pair
  user_data     = data.template_file.user_data.rendered
  vpc_security_group_ids = ["${aws_security_group.default.id}"]
  subnet_id = var.key_pair

}

In the parent folder create a file named k6_data.sh under templates folder and add the script to install k6. This will run after the instance is started.

wget https://bintray.com/loadimpact/rpm/rpm -O bintray-loadimpact-rpm.repo
sudo mv bintray-loadimpact-rpm.repo /etc/yum.repos.d/
sudo yum install -y k6

In the similar way we need to create instances for Grafana and influx DB to run and add user data configs which will be initiated once the EC2 instances are up.

For Grafana:

wget https://dl.grafana.com/oss/release/grafana-7.1.0-1.x86_64.rpm
sudo yum install -y grafana-7.1.0-1.x86_64.rpm
sudo service grafana-server start
sudo /sbin/chkconfig --add grafana-server

For Influx DB:

wget https://dl.influxdata.com/influxdb/releases/influxdb-1.7.6.x86_64.rpm
sudo yum localinstall -y influxdb-1.7.6.x86_64.rpm
sudo systemctl enable influxdb.service

In Influx DB after installing the service we need to create data directories, Users and a database.

This should be done after starting the service using systemctl

influx -execute "create user admin with password 'mongoose123' with all privileges"
influx -execute "create user itguy with password 'itguy123' "
influx -execute "create database k6LoadTestDB"
influx -execute "grant ALL on k6LoadTestDB to grafana"

In order for Grafana to run generate reports from the data in Influx DB during test execution we need to configure Grafana to listen to the port in the Load Balancer.

Hope this article helps !!!!

Mobile App Automation with AWS Device Farm, Gitlab and Appium

Benson Michael — Tue, 04 Jul 2023 03:38:01 +0000

Summary:
This post talks about how you can deploy and run your Appium Automation code into AWS Device Farm from Gitlab and your Release Platform eg. Visual Studio App Center.

WorkFlow:

Developer merges code to Gitlab Repo.
Repo will trigger Webhook to Release Platform to download code and build app for multiple platforms. (Android / iOS)
Once App file (.apk or .ipa) file is built Release Platform will send a Webhook notification to Gitlab to trigger Automation pipeline.
This pipeline will have 3 jobs:
- Download and upload the installable build files (.apk or .ipa) to AWS Device farm.
- Upload Latest Test Scripts to AWS Device Farm.
- Execute Automation Run in Android and iOS, download test reports.

Stages

Setup Webhook in Release Platform to trigger Pipeline on Successful App Build.
Setup Job in Pipeline to download generated build and upload to AWS Device Farm.
Setup Job in pipeline to upload latest version of Appium test scripts to AWS Device Farm.
Trigger Automation Run in AWS Device Farm.

Setup Webhook in Release Platform.

Create a trigger token in from your Gitlab account
https://docs.gitlab.com/ee/ci/triggers/
Construct the Webhook URL
https://gitlab.example.com/api/v4/projects/<project_id>/ref/<ref_name>/trigger/pipeline?token=<token>
In App Center if you go to Settings -> Webhooks, you can create your webhook with the above generated Gitlab pipeline trigger URL.
https://appcenter.ms/orgs/<your organization>/apps/<your app>/settings/webhooks/create
Configure when the webhook should be triggered.
Configure webhooks for Android and iOS apps separately so that it does not conflict with each other.

Upload latest build to AWS Device Farm

Create a Automation Test Project from AWS console in the Device Farm Service. Note down the Project ARN, Test Spec ARN etc.
While setting up make sure the Test spec is as per your requirements. Make edits if needed.
Once the Pipeline is trigger is configured, create a Gitlab Job, that executes a bash script.
In the bash script, use App Center API via curl to get the the buildID for the latest build generated.
$(curl -X GET "https://api.appcenter.ms/v0.1/apps/<your-organization>/<APP_NAME>/branches/develop/builds" -H "accept: application/json" -H "X-API-Token: <APIToken>")
Here APIToken is App Center API Token. You can add this to Gitlab Environment Variables and consume it in the pipeline.
Once the buildID is fetched you can download the build using
$(curl -X GET "https://api.appcenter.ms/v0.1/apps/<your-organization>/<APP_NAME>/builds/<build_id>/downloads/build" -H "accept: application/json" -H "X-API-Token: <APIToken>")
After downloading, you can use the aws cli command to upload it to the AWS Device farm.
aws devicefarm create-upload --project-arn <device-farm-arn> --name <build-file-name> --type <extension>

Upload Test Scripts to Appium.

Create a job in Gitlab pipeline that executes a bash script.
In the bash script, navigate to the test folder and using npm-bundle plugin generate a zip file off the tests folder.

npm install -g npm-bundle
npm i
npm-bundle
zip -r appium-test.zip *.tgz

Once the zip file is generated use aws cli command to upload it to the device farm.

aws devicefarm create-upload --project-arn <device-farm-arn> --name "appium-test.zip" --type APPIUM_NODE_TEST_PACKAGE

Trigger Automation Run in AWS Device Farm

Once both the latest build (.apk or .ipa) file is successfully upload to the device farm. Create a python script with reference to this document.

https://docs.aws.amazon.com/devicefarm/latest/developerguide/api-ref.html

You might have to pass the Device Farm Project ARN, Test Spec ARN, Device Pool ARN , App Name and Test Package Name as arguments to the python script. These ARN values are obtained from Device Farm Dashboard in AWS Console.
Under Device Farm -> Mobile Device: Projects ->
When this script is executed, it will trigger the automation run and once done, the report will be saved in Gitlab artifacts.

Here is an example screenshot:

Hope this document helps it setting up Mobile Automation in AWS Device Farm from Gitlab. Let me know if you have any questions in the comments.

Forem: Benson Michael