Blog

Performance Testing with K6: Run Your First Performance Test

by Hannah Rivera | Jan 27, 2025 | Performance Testing, Blog, Latest Post | 0 comments

In today’s fast-paced digital era, where user experience can make or break a brand, ensuring your applications perform seamlessly under different loads is non-negotiable. Performance Testing is no longer just a phase; it’s a crucial part of delivering reliable and high-performing web applications. This is where K6 steps in—a modern, developer-friendly, and powerful tool designed to elevate your performance testing game.

Whether you’re a beginner looking to dip your toes into load testing or an experienced engineer exploring scalable solutions, this guide will introduce you to the essentials of Performance Testing with K6. From creating your first test to mastering advanced techniques, you’ll discover how K6 helps simulate real-world traffic, identify bottlenecks, and optimize your systems for an exceptional user experience.

Key Highlights

• Learn why performance testing is important for modern web apps. It helps manage load, response times, and improves user experience.
• Get to know K6, a free tool used for load testing. It helps developers create real traffic situations.
• Find out how to write your first performance test script with K6. This includes setting up your space, defining tests, and running them.
• Discover useful tips like parameterization, correlation, and custom metrics. These can make your performance testing better.
• See how to use K6 with popular CI tools like Jenkins.

Understanding Performance Testing

Performance testing is a crucial process in ensuring that an application performs reliably and efficiently under various loads and conditions. It evaluates system behavior, response times, stability, and scalability by simulating real-world traffic and usage scenarios. This type of testing helps identify bottlenecks, optimize resource usage, and ensure a seamless user experience, especially during peak traffic. By implementing performance testing early in the development lifecycle, organizations can proactively address issues, reduce downtime risks, and deliver robust applications that meet user expectations.

The Importance of Performance Testing in Modern Web Applications

In our digital world, people expect a lot from apps. This makes performance very important for an app to succeed. Page load time matters a lot. If an app takes too long to load, has unresponsive screens, or crashes often, users will feel upset. They may even stop using the app.

Load testing is an important part of performance testing. It checks how a system performs when many users send requests at once. By simulating traffic that acts like real users, load testing can find performance issues that regular testing might miss.

Fixing issues early makes customers happy. It also helps protect your brand name. Plus, it makes your web application last longer. For this reason, you should include performance testing in your development process.

Different Types of Performance Testing

• Load Testing: Evaluates how an application performs under expected user loads to identify bottlenecks and ensure reliability.
• Stress Testing: Pushes the system beyond its normal operational capacity to determine its breaking point and how it recovers from failure.
• Scalability Testing: Assesses the system’s ability to scale up or down in response to varying workloads while maintaining performance.
• Endurance Testing (Soak Testing): Tests the application over an extended period to ensure it performs consistently without memory leaks or degradation.
• Spike Testing: Measures system performance under sudden and extreme increases in user load to evaluate its ability to handle traffic spikes.
• Volume Testing: Checks how the application handles large volumes of data, such as database loads or file transfers.

Introduction to K6 for Performance Testing

K6 is a strong and flexible open-source tool for performance testing. It is built from our years of experience. K6 helps developers understand how their applications run in different situations. One of its best features is making realistic user traffic. This allows applications to be tested at their limits. It also provides detailed reports to highlight any performance bottlenecks.

K6 is a favorite among developers. It is popular because it has useful features and is simple to use. In this guide, you will find a complete table of contents. You will learn how to use K6’s features effectively. This will help you begin your journey in performance testing.

What is K6 and Why Use It?

K6 is a free tool for load testing. A lot of people like it because it is made for developers and has good scripting features. It is built with Go and JavaScript. K6 makes it easy to write clear test scripts. This helps you set up complex user scenarios without trouble.

People like K6 because it is simple to use, flexible, and provides great reporting features. K6 works well with popular CI/CD pipelines. This makes performance testing easy and automatic. Its command-line tool and online platform allow you to run tests, see results, and find bottlenecks.

K6 is a great tool for everyone. It is useful for both skilled performance engineers and developers just starting with load testing. K6 is easy to use and very effective. It helps you understand how well your applications are running.
Key Features and Benefits of Using K6

K6 has many features to make load testing better. A great feature is its ability to simulate several virtual users. These users can all access your application at the same time. This helps you see how well your application works when there is real traffic.K6 uses JavaScript and HTML to run its scripts. This helps you create situations that feel like real user actions. You can make HTTP requests and work with different endpoints. The tool lets you manage test settings. You can adjust the number of virtual users, request rates, and the duration of the test. Feel free to change these settings to fit your needs.

K6 offers detailed reports and metrics. You can check response times, the speed of operations, and the frequency of errors. It works well with well-known visualization tools. This makes it easier to spot and solve bottlenecks in performance.

Getting Started with K6

Getting started with K6 is easy. You can set it up quickly and be ready to do performance testing like a pro. We will help you with the steps to install it. This will give you everything you need to start your K6 performance testing journey.

First, let’s check that you have all you need to use K6. Setting it up is simple. You won’t need any special machine to get started.

System Requirements and Prerequisites for K6

Before you start your K6 journey, let’s check if your local machine is ready. The good news is that K6 works well on different operating systems.

Here’s a summary:

• Operating Systems: K6 runs on Linux, macOS, and Windows. This makes it easy for more developers to use.
• Runtime: K6 is mainly a command-line interface (CLI) tool. It uses very little system resources. A regular development machine will work well.
• Package Manager: You can install it easily if you have a package manager. Common ones are apt for Debian, yum for Red Hat, Homebrew for macOS, and Chocolatey for Windows.

Installing K6 on Your Machine

With your system ready, let’s install K6. The steps will be different based on your operating system.

• Windows:Download the K6 binary from GitHub releases, extract it, add the folder to your PATH, and verify by typing k6 version in Command Prompt or PowerShell.
• macOS: Using a package manager is easy with Homebrew. Just type: brew install k6.
• Linux: If you’re on a Debian-based system like Ubuntu, use this command: sudo apt-get install k6. For Red Hat-based systems like CentOS or Fedora, type: sudo dnf install k6.
• Docker: With Docker, you can create a stable environment. Type: docker pull loadimpact/k6.

To check if the installation worked, open your terminal. Type k6 –version and press enter. You should see your version of K6. If you see it, you are all set to start making and running load tests.

Step 1: Setting Up Your Testing Environment

Before you begin writing any code, set up your environment first. This will make it easier to test your project. Start by creating a folder for your K6 project. Keeping your files organized is good for version control. Inside this folder, create a new file and name it first-test.js.

K6 lets you easily change different parts of your tests. You can adjust the number of virtual users and the duration of the test. For now, let’s keep it simple.
Open first-test.js in your favorite text editor. We will create a simple test scenario in this file.

Step 2: Writing Your First Script

Now that you have your test file ready, let’s create the script for your first K6 test. K6 uses JavaScript, which many developers know. In your first-test.js file, write the code below. This script will set up a simple scenario. It will have ten virtual users sending GET requests to a specific API endpoint URL at the same time.

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '30s', target: 10 }, // Ramp up to 10 users over 30 seconds
    { duration: '1m', target: 10 }, // Stay at 10 users for 1 minute
    { duration: '10s', target: 0 }, // Ramp down to 0 users
  ],
};

export default function () {
  const res = http.get('https://test-api.k6.io/public/crocodiles/');
  check(res, { 'status was 200': (r) => r.status === 200 });
  sleep(1);
}

Now, save your first-test.js file. After that, we can move on to the exciting part: running your first load test with K6.

Step 3: Executing the Test

Go to your project folder in the project directory using your terminal. Then, run this command:

k6 run first-test.js

This command tells K6 to read and run your script. By default, K6 creates ten virtual users. Each of these users will send a GET request to the API you set up. You can see the test results in real time in your terminal.

Result

         /\      |‾‾|  /‾‾/  /‾/
     /\  /  \     |  |_/  /  / /
    /  \/    \    |      |  /  ‾‾   /          \   |  |‾\  \ | (_) |
  / __________ \  |__|  \__\ \___/ .io

  execution: local
     script: first-test.js
     output: -

  scenarios: (100.00%) 1 executors, 50 max VUs, 1m30s max duration (incl. graceful stop):
           * default: 50 looping VUs for 1m0s (gracefulStop: 30s)


running (1m02.5s), 00/50 VUs, 1000 complete and 0 interrupted iterations
default ✓ [======================================] 50 VUs  1m0s


    data_received..............: 711 kB 11 kB/s
    data_sent..................: 88 kB  1.4 kB/s
    http_req_blocked...........: avg=8.97ms   min=1.37µs   med=2.77µs   max=186.58ms p(90)=9.39µs   p(95)=8.85ms
    http_req_connecting........: avg=5.44ms   min=0s       med=0s       max=115.8ms  p(90)=0s       p(95)=5.16ms
    http_req_duration..........: avg=109.39ms min=100.73ms med=108.59ms max=148.3ms  p(90)=114.59ms p(95)=119.62ms
    http_req_receiving.........: avg=55.89µs  min=16.15µs  med=37.92µs  max=9.67ms   p(90)=80.07µs  p(95)=100.34µs
    http_req_sending...........: avg=15.69µs  min=4.94µs   med=10.05µs  max=109.1µs  p(90)=30.32µs  p(95)=45.83µs
    http_req_tls_handshaking...: avg=0s       min=0s       med=0s       max=0s       p(90)=0s       p(95)=0s
    http_req_waiting...........: avg=109.31ms min=100.69ms med=108.49ms max=148.22ms p(90)=114.54ms p(95)=119.56ms
    http_reqs..................: 1000   15.987698/s
    iteration_duration.........: avg=3.11s    min=3.1s     med=3.1s     max=3.3s     p(90)=3.12s    p(95)=3.15s
    iterations.................: 1000   15.987698/s
    vus........................: 50     min=50 max=50
    vus_max....................: 50     min=50 max=50

K6’s results give helpful information about different performance metrics. This includes how long requests take, how many requests are sent each second, and any errors that happen. You can use this data to analyze the performance of your application.

Step 4: Analyzing Test Results

Congrats on completing your first K6 test! Now, let’s look at the test results. We will see what they say about how your application is working.

K6 shows results clearly. It points out key metrics such as:

• http_req_blocked: refers to the time spent waiting for a free TCP connection to send an HTTP request.
• http_req_connecting: refers to the time spent establishing a TCP connection between the client (K6) and the server.
• http_req_duration: represents the total time taken to complete an HTTP request, from the moment it is sent to the moment the response is fully received.
• iterations: Total test iterations.

K6’s output provides helpful information. Yet, seeing these metrics in a visual form can make them easier to grasp. You might consider connecting K6 to a dashboard tool such as Grafana. This will help you see clearer visuals and follow performance trends over time.

Optimize performance testing with expert tips and insights. Improve processes and achieve better results today!

Reach Us for Better Service

Advanced K6 Testing Techniques

As you keep going on your performance testing path with K6, you may face times when you need more control and detailed test cases. The good news is K6 has features that can help with these advanced needs.

Let’s explore some advanced K6 techniques. These can help you create more realistic and strict load tests.

Parameterization and Correlation in Tests

Parameterization puts changing data into your tests. This makes your tests seem more real. For instance, when you test user registration, you can use different usernames for each virtual user. This is better than using the same name over and over again. K6 provides tools to help with this process. It lets you get data from outside sources, like CSV files.

Correlation is important for parameterization. It keeps data consistent during tests. For example, when you log in and go to a page made for you, correlation makes sure it uses the correct user ID from the login. This works just like a real user session.

Using these methods makes your load tests feel more realistic. They help you find hidden bottlenecks in performance. If you mix different data and keep it stable during your test, you can see how your application works in various situations.

Implementing Custom Metrics for In-depth Analysis

K6 has several built-in metrics. However, for real-world projects, using custom metrics can be better. For example, you might want to check how long it takes for a specific database query in your API. K6 lets you make and track these custom metrics. This helps you understand any bottlenecks that may occur.

You can use K6’s JavaScript API to monitor timings, counts, and other special values. Then, you can add these custom metrics to your test results. This extra detail can help you spot performance issues that you might overlook with regular metrics.

You can see how often a database gets used when a user takes certain actions. This shows you what can be improved. By setting up custom metrics for your app’s key activities, you gain valuable information. This information helps you locate and resolve performance bottlenecks more easily.

Integrating K6 with Continuous Integration (CI) Tools

To connect k6 with continuous integration (CI) tools, first, place your test scripts in a GitHub repository. Next, set up your CI workflow to run the test file with k6 on a CI server, following a tutorial. You will need to select the number of virtual users, requests, and the duration of the test run. Use the dashboard to see metrics, like response time and throughput. Set up assertions to find any bottlenecks in performance. By automating performance tests in your CI/CD pipeline, you can catch problems early and keep your application strong.

Configuring K6 with Jenkins

Jenkins is a popular tool for CI/CD. It helps you automate tasks in your development process. When you use K6 with Jenkins, you can automatically run performance tests. This takes place every time someone changes the code in your repository.

You should begin by installing K6 on your Jenkins server. Jenkins has a special K6 plugin that makes this process easier. After you install and set up the plugin, you can add K6 tests to your current Jenkins jobs. You can also make new jobs specifically for performance testing.

In your Jenkins job settings, pick the K6 test script that you wish to run. You can also use different K6 command-line options in Jenkins. This lets you change the test settings right from your CI server.

Automating Performance Tests in CI/CD Pipelines

Integrating K6 into your CI/CD pipeline helps make performance testing a key part of your development workflow. This allows you to discover performance issues early on. By doing this, you can prevent these issues from impacting your users.

Set up your pipeline to automatically run K6 tests whenever new code is added. In your K6 scripts, you can define performance goals. If your code does not meet these goals, the pipeline will fail. This way, your team can quickly spot any performance issues caused by recent code changes.

Think about having different performance goals for each part of the pipeline. For example, you might set simpler goals during development. In production, you can then set more demanding goals.

Best Practices for Performance Testing with K6

K6 gives you all the tools you need for performance testing. To get good results in your tests, it is important to use best practices. Being consistent and following these practices is very important.

Here are some helpful tips to boost your performance testing with K6.

Effective Script Organization and Management

As your K6 test suite grows, it is important to make your code easy to read and organized. You should keep a clear structure for your tests. Group similar test cases and use simple names for your files and functions.

Use K6’s modularity to help you. Break your tests into smaller, reusable modules. This will help you use code again and make it easier to maintain. This method is very useful when your tests get more complex. It lets you manage everything better.

• Use a version control system, like Git, to monitor changes in your test scripts.
• This helps teamwork and lets you go back to earlier versions easily.
• Think about keeping your K6 scripts in a separate repository.
• This keeps them tidy and separate from your application code.

Optimizing Test Execution Time

Long tests can slow things down. This is very important in a CI/CD environment where quick feedback matters. You need to shorten the time it takes for tests to run. First, look for delays or long sleep timers in your test scripts. Remove them to make everything faster.

Sometimes, you need to take breaks to see how real users behave. But be careful. Long breaks can make the test time feel fake. If you have to include delays, keep them brief. This way, you can keep the test quality high.

You should cut down the number of requests during your tests. Concentrate only on the important requests for your situation. Extra requests can slow down the testing process. Carefully examine your test scenarios. Take out any extra or unneeded requests. This will help boost the overall execution time.

Conclusion

In conclusion, using K6 for performance testing can really help your web application work better. It can also make users feel happier about your site. It’s important to understand the types of performance testing. You should be able to easily connect K6 with CI tools. Using K6 Cloud will allow you to expand your tests. By following good practices, like managing your scripts and improving your methods, you can get great results. Whether you are new or experienced, K6 can help you find and fix performance bottlenecks. This way, your applications will be more reliable and work better. Start your journey with K6 today!

Frequently Asked Questions