0Pricing
Load Testing & Performance Benchmarking (JMeter & k6) · Lekcja

Parametryzacja danych w k6

Zaimplementuj parametryzację danych w skryptach k6, aby używać zewnętrznych źródeł danych jako danych wejściowych testów.

Parametryzacja danych w k6 to bezpłatna lekcja Load Testing & Performance Benchmarking (JMeter & k6) na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Load Testing & Performance Benchmarking (JMeter & k6), a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Load Testing & Performance Benchmarking (JMeter & k6) zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

Dynamic Data in k6 Tests

When performance testing, you rarely want every virtual user (VU) to do exactly the same thing with the exact same data. Real users behave differently!

Data parameterization is the technique of using external data sources to feed dynamic inputs into your test scripts.

Why Parameterize Test Data?

Imagine testing a login page. If all VUs try to log in with "user1" and "pass1", you're not testing unique user scenarios. This can lead to:

  • Unrealistic load patterns
  • Caching issues
  • Errors from duplicate operations

Parameterization helps simulate diverse, realistic user behavior.

SharedArray for Efficient Data

In k6, the SharedArray is your go-to for loading external data efficiently. It's designed to load data once at the start of the test, and then share it across all virtual users (VUs).

  • Load Once: Prevents redundant file reads.
  • Immutable: Data cannot be changed by VUs.
  • Efficient: Reduces memory overhead.

Loading JSON with SharedArray

Let's start by loading a simple JSON array of user credentials. In a real test, you'd use open('./users.json') to read a local file. For this runnable example, we'll embed the JSON data directly.

import { SharedArray } from 'k6/data';
import http from 'k6/http';
import { sleep } from 'k6/execution';

const users = new SharedArray('user_data', function () {
  // In a real test, you'd use open('./users.json')
  // For this runnable example, we'll use inline JSON data:
  const inlineJson = `[
    {"username": "user1", "password": "password1"},
    {"username": "user2", "password": "password2"}
  ]`;
  return JSON.parse(inlineJson);
});

export default function () {
  const user = users[Math.floor(Math.random() * users.length)]; // Pick a random user
  console.log(`VU ${__VU} using user: ${user.username}`);

  // Simulate a request
  http.get('https://test.k6.io');
  sleep(1);
}

Using Parameterized JSON

With the SharedArray loaded, each virtual user (VU) can pick a unique or random entry to use in its requests. This simulates different users logging in or performing actions.

Notice how we pick a user based on __VU % users.length to distribute users evenly. This user's data is then available for your HTTP requests.

import { SharedArray } from 'k6/data';
import http from 'k6/http';
import { sleep } from 'k6/execution';

const users = new SharedArray('user_data', function () {
  const inlineJson = `[
    {"username": "alice", "password": "passA"},
    {"username": "bob", "password": "passB"},
    {"username": "charlie", "password": "passC"}
  ]`;
  return JSON.parse(inlineJson);
});

export default function () {
  const user = users[__VU % users.length]; // Distribute users evenly
  console.log(`VU ${__VU} logging in as: ${user.username}`);

  const payload = JSON.stringify({
    username: user.username,
    password: user.password,
  });

  const params = {
    headers: {
      'Content-Type': 'application/json',
    },
  };

  // Simulate a login request
  http.post('https://test.k6.io/login', payload, params);
  sleep(1);
}

Loading CSV with SharedArray

CSV (Comma Separated Values) files are another common way to store test data. SharedArray can handle these too, but requires a small parsing step.

Imagine a products.csv file:

product_id,product_name,price
101,Laptop,1200
102,Mouse,25
103,Keyboard,75

You'll read this file and parse each line.

Parsing CSV in k6

To parse CSV data, you'll typically read the file line by line, split by comma, and then map it to an object. The k6/data module doesn't have a built-in CSV parser, so you'll do it manually or use a simple helper.

Here's how to load and parse a CSV string, making sure to skip the header row:

import { SharedArray } from 'k6/data';
import http from 'k6/http';
import { sleep } from 'k6/execution';

const products = new SharedArray('product_data', function () {
  // For runnable example, use inline CSV content
  const csvData = `product_id,product_name,price\n101,Laptop,1200\n102,Mouse,25\n103,Keyboard,75`;

  const lines = csvData.split('\n');
  const headers = lines[0].split(','); // Get headers
  const data = [];

  for (let i = 1; i < lines.length; i++) { // Start from second line (skip header)
    const values = lines[i].split(',');
    const row = {};
    for (let j = 0; j < headers.length; j++) {
      row[headers[j]] = values[j];
    }
    data.push(row);
  }
  return data;
});

export default function () {
  const product = products[__VU % products.length]; // Distribute products
  console.log(`VU ${__VU} viewing product: ${product.product_name}`);

  // Simulate viewing a product page
  http.get(`https://test.k6.io/products/${product.product_id}`);
  sleep(1);
}

Using Parameterized CSV

Once your CSV data is loaded and parsed into an array of objects by SharedArray, you can access its properties just like with JSON data. This allows you to construct dynamic URLs, request bodies, or headers.

In the example, each VU accesses a product's product_id and product_name to simulate browsing different product pages, then adds it to a cart.

import { SharedArray } from 'k6/data';
import http from 'k6/http';
import { sleep } from 'k6/execution';

const products = new SharedArray('product_data', function () {
  const csvData = `product_id,product_name,price\n101,Laptop,1200\n102,Mouse,25\n103,Keyboard,75`;

  const lines = csvData.split('\n');
  const headers = lines[0].split(',');
  const data = [];

  for (let i = 1; i < lines.length; i++) {
    const values = lines[i].split(',');
    const row = {};
    for (let j = 0; j < headers.length; j++) {
      row[headers[j]] = values[j];
    }
    data.push(row);
  }
  return data;
});

export default function () {
  const product = products[__VU % products.length]; // Distribute products
  console.log(`VU ${__VU} adding ${product.product_name} to cart`);

  const payload = JSON.stringify({
    productId: product.product_id,
    quantity: 1,
    price: product.price,
  });

  const params = {
    headers: {
      'Content-Type': 'application/json',
    },
  };

  // Simulate adding a product to cart
  http.post('https://test.k6.io/cart/add', payload, params);
  sleep(1);
}

Distributing Data to VUs

How do VUs get their data? You've seen two common patterns:

  • Random: data[Math.floor(Math.random() * data.length)] - Each VU picks a random item. Good for a large pool of interchangeable data.
  • Even Distribution: data[__VU % data.length] - Each VU gets a unique item in a round-robin fashion. Useful when you have fewer data items than VUs and want to ensure each is used.

Choose the method that best simulates your real user behavior.

Check Your Understanding

Which of the following statements about k6's SharedArray for data parameterization are TRUE?

Recap: Dynamic Data in k6

You've learned how to bring your k6 tests to life with dynamic data! We covered:

  • The importance of data parameterization for realistic tests.
  • Using k6's SharedArray to efficiently load and share data.
  • Examples for loading and using both JSON and CSV data.
  • Strategies for distributing data to individual virtual users.

Next, explore how to extract dynamic values from server responses (correlation)!

Często zadawane pytania

Czy lekcja „Parametryzacja danych w k6” jest bezpłatna?

Tak — pełny tekst „Parametryzacja danych w k6” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Load Testing & Performance Benchmarking (JMeter & k6), przejdź na CoddyKit PRO. Kurs Load Testing & Performance Benchmarking (JMeter & k6) zawiera 4 lekcji w sumie.

Co nauczysz się w „Parametryzacja danych w k6”?

Zaimplementuj parametryzację danych w skryptach k6, aby używać zewnętrznych źródeł danych jako danych wejściowych testów. Ćwiczysz Load Testing & Performance Benchmarking (JMeter & k6) z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Load Testing & Performance Benchmarking (JMeter & k6)?

Nie wymagamy żadnego doświadczenia. Load Testing & Performance Benchmarking (JMeter & k6) w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Parametryzacja danych w k6”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Load Testing & Performance Benchmarking (JMeter & k6)?

Tak. Każda lekcja Load Testing & Performance Benchmarking (JMeter & k6) zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Scenariusze wirtualnych użytkowników (VU)
  2. Parametryzacja danych w k6
  3. Uruchamianie w chmurze za pomocą k6
  4. Niestandardowe metryki i trendy w k6
← Powrót do Load Testing & Performance Benchmarking (JMeter & k6)