0Pricing
Load Testing & Performance Benchmarking (JMeter & k6) · Lección

Parametrización de datos en k6

Implemente la parametrización de datos en scripts de k6 para utilizar fuentes de datos externas como entradas de prueba.

Parametrización de datos en k6 es una lección gratuita de Load Testing & Performance Benchmarking (JMeter & k6) en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Load Testing & Performance Benchmarking (JMeter & k6), y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Load Testing & Performance Benchmarking (JMeter & k6) incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

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)!

Preguntas frecuentes

¿La lección «Parametrización de datos en k6» es gratis?

Sí — el texto completo de «Parametrización de datos en k6» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Load Testing & Performance Benchmarking (JMeter & k6), actualiza a CoddyKit PRO. El curso de Load Testing & Performance Benchmarking (JMeter & k6) incluye 4 lecciones en total.

¿Qué aprenderé en «Parametrización de datos en k6»?

Implemente la parametrización de datos en scripts de k6 para utilizar fuentes de datos externas como entradas de prueba. Practicas Load Testing & Performance Benchmarking (JMeter & k6) con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Load Testing & Performance Benchmarking (JMeter & k6)?

No se requiere experiencia previa. Load Testing & Performance Benchmarking (JMeter & k6) en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Parametrización de datos en k6»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Load Testing & Performance Benchmarking (JMeter & k6)?

Sí. Cada lección de Load Testing & Performance Benchmarking (JMeter & k6) incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Escenarios de usuarios virtuales (VUs)
  2. Parametrización de datos en k6
  3. Ejecución de k6 en la nube
  4. Métricas personalizadas y tendencias en k6
← Volver a Load Testing & Performance Benchmarking (JMeter & k6)