ಕಾರ್ಯಕ್ಷಮತೆ ಪರೀಕ್ಷೆಗಾಗಿ ಗ್ಯಾಟ್ಲಿಂಗ್ ಯೋಜನೆಯನ್ನು ಸಂಘಟಿಸಲು ಮತ್ತು ರಚಿಸಲು ಉತ್ತಮ ಮಾರ್ಗ ಯಾವುದು?
ಚೌಕಟ್ಟನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವಾಗ, ನಾವು ನಿರ್ವಹಣೆ ಮತ್ತು ವಿಸ್ತರಣೆಯ ಬಗ್ಗೆ ಯೋಚಿಸಬೇಕು, ಹೀಗಾಗಿ ನಾವು ಘಟಕಗಳನ್ನು ಹೇಗೆ ಸಂಘಟಿಸುತ್ತೇವೆ ಎಂಬುದು ಬಹಳ ಮುಖ್ಯ.
ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ, ಗ್ಯಾಟ್ಲಿಂಗ್ ಮತ್ತು ಮಾವೆನ್ ಬಳಸಿ ಮೊದಲಿನಿಂದ ಕಾರ್ಯಕ್ಷಮತೆ ಪರೀಕ್ಷಾ ಚೌಕಟ್ಟನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂದು ನಾವು ತೋರಿಸುತ್ತೇವೆ.
ಪೂರ್ವ ಅವಶ್ಯಕತೆಗಳು:
ಈ ಟ್ಯುಟೋರಿಯಲ್ ಗಾಗಿ ನೀವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಸ್ಥಾಪಿಸಬೇಕಾಗಿದೆ:
ಮೊದಲಿಗೆ, ಮ್ಯಾವೆನ್ ಗ್ಯಾಟ್ಲಿಂಗ್ ಮೂಲರೂಪವನ್ನು ಚಲಾಯಿಸುವ ಮೂಲಕ ನಾವು ಮೂಲ ಯೋಜನೆಯನ್ನು ರಚಿಸುತ್ತೇವೆ:
mvn archetype:generate -DarchetypeGroupId=io.gatling.highcharts -DarchetypeArtifactId=gatling-highcharts-maven-archetype
ಮೇಲಿನ ಆಜ್ಞೆಯನ್ನು ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಿದಾಗ, ಅದು ಅವಲಂಬನೆಗಳನ್ನು ಡೌನ್ಲೋಡ್ ಮಾಡಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.
ಕೇಳಿದಾಗ, ‘ಗ್ರೂಪ್ಐಡ್’, ‘ಆರ್ಟಿಫ್ಯಾಕ್ಟ್ಐಡ್’ ಮತ್ತು ‘ಆವೃತ್ತಿ’ ಗಾಗಿ ಮೌಲ್ಯಗಳನ್ನು ಒದಗಿಸಿ.
ನನ್ನ ಸೆಟಪ್ ಈ ಕೆಳಗಿನಂತೆ ಕಾಣುತ್ತದೆ:
ನೀವು ಯೋಜನೆಯನ್ನು ತೆರೆದಾಗ, ಕೆಲವು ಡೀಫಾಲ್ಟ್ ಫೈಲ್ಗಳು ಮತ್ತು ಫೋಲ್ಡರ್ಗಳಿವೆ ಎಂದು ನೀವು ಗಮನಿಸಬಹುದು.
ಸಂಪನ್ಮೂಲಗಳ ಅಡಿಯಲ್ಲಿ, ನಾವು ಹೊಂದಿದ್ದೇವೆ
ದೇಹಗಳು ಈ ಪ್ಯಾಕೇಜ್ ವಿನಂತಿಯ ಪೇಲೋಡ್ಗಳನ್ನು ಹೊಂದಿದೆ. ಉದಾಹರಣೆಗೆ, ನೀವು ವಿವಿಧ ವಿನಂತಿಗಳಿಗಾಗಿ ವಿನಂತಿಗಳ ಟೆಂಪ್ಲೆಟ್ಗಳನ್ನು ಹೊಂದಬಹುದು.
ಡೇಟಾ ಈ ಪ್ಯಾಕೇಜ್ CSV ಗಳಂತಹ ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳಿಗೆ ನೀವು ನೀಡಬೇಕಾದ ಡೇಟಾವನ್ನು ಹೊಂದಿದೆ.
ಮೇಲಿನ ಎರಡು ಫೋಲ್ಡರ್ಗಳ ಜೊತೆಗೆ, ಗ್ಯಾಟ್ಲಿಂಗ್ಕಾನ್ಫ್, ಲಾಗ್ಬ್ಯಾಕ್.ಎಕ್ಸ್ಎಂಎಲ್ ಮತ್ತು ರೆಕಾರ್ಡರ್ ಕಾನ್ಫ್ ಫೈಲ್ಗಳಿವೆ. ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ ನಾವು ಇವುಗಳನ್ನು ಚರ್ಚಿಸುತ್ತಿಲ್ಲ.
ಗ್ಯಾಟ್ಲಿಂಗ್ ಮಾವೆನ್ ಆರ್ಕೈಟೈಪ್ ಮೂರು ಬೇಸ್ ಸ್ಕಲಾ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಸಹ ರಚಿಸುತ್ತದೆ, ಆದರೆ ನಾವು ಅವುಗಳನ್ನು ಬಳಸುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಮುಂದುವರಿಯಿರಿ ಮತ್ತು ವಸ್ತುಗಳನ್ನು ಅಳಿಸಿ.
ಹೆಚ್ಚುವರಿಯಾಗಿ, ನಾವು ನಾಲ್ಕು ಪ್ಯಾಕೇಜುಗಳನ್ನು ರಚಿಸುತ್ತೇವೆ, ಸಂರಚನೆ , ವಿನಂತಿಗಳು , ಸನ್ನಿವೇಶಗಳು , ಮತ್ತು ಸಿಮ್ಯುಲೇಶನ್ಗಳು :
ಸಂರಚನಾ ಪ್ಯಾಕೇಜ್ನಲ್ಲಿ, ಕಾನ್ಫಿಗರ್ ಎಂಬ ಸ್ಕಲಾ ವಸ್ತುವನ್ನು ರಚಿಸಿ. ಇದು ನಮ್ಮ ಯೋಜನೆಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್ URL ಗಳು, ಡೀಫಾಲ್ಟ್ ಬಳಕೆದಾರರು ಮುಂತಾದ ವಿವಿಧ ಸಂರಚನೆಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ…
package io.devqa.config object Config {
val app_url = 'http://example-app.com'
val users = Integer.getInteger('users', 10).toInt
val rampUp = Integer.getInteger('rampup', 1).toInt
val throughput = Integer.getInteger('throughput', 100).toInt }
ವಿನಂತಿಗಳ ಪ್ಯಾಕೇಜ್ ವಿಭಿನ್ನ ಕಾರ್ಯಾಚರಣೆಯ ವಿನಂತಿಗಳನ್ನು ಹೊಂದಿದೆ. ಉದಾಹರಣೆಗೆ, ಅಧಿಕೃತ ಟೋಕನ್ ಪಡೆಯುವ ವಿನಂತಿಯನ್ನು ನಾವು ಹೊಂದಬಹುದು. ಮತ್ತೊಂದು ವಿನಂತಿಯು ಬಳಕೆದಾರರನ್ನು ರಚಿಸಲು ಹಿಂದಿನ ವಿನಂತಿಯಿಂದ ಟೋಕನ್ ಅನ್ನು ಬಳಸಬಹುದು ಮತ್ತು ಹೀಗೆ.
ಇವುಗಳು ವಿಭಿನ್ನ ಮತ್ತು ಪ್ರತ್ಯೇಕ ವಿನಂತಿಗಳಾಗಿವೆ.
GetTokenRequest
package io.devqa.requests import io.gatling.core.Predef._ import io.gatling.http.Predef._ import io.devqa.config.Config.app_url object GetTokenRequest {
val get_token = http('RequestName').get(app_url + '/token')
.check(status is 200)
.check(jsonPath('$..token').saveAs('token')) }
CreateUserRequest
package io.devqa.requests import io.devqa.config.Config.app_url import io.gatling.core.Predef._ import io.gatling.http.Predef._ object CreateUserRequest {
val sentHeaders = Map('Authorization' -> 'bearer ${token}')
val create_user = exec(http('Create User Request')
.post(app_url + '/users')
.headers(sentHeaders)
.formParam('name', 'John')
.formParam('password', 'John5P4ss')
.check(status is 201)
.check(regex('Created').exists)) }
ಸನ್ನಿವೇಶದ ಪ್ಯಾಕೇಜ್ ವ್ಯವಹಾರದ ಸನ್ನಿವೇಶಗಳನ್ನು ಹೊಂದಿದೆ. ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರರನ್ನು ರಚಿಸಲು, ನಾವು ಮೊದಲು ದೃ uth ೀಕರಣ ಟೋಕನ್ ಪಡೆಯಬೇಕು ಮತ್ತು ನಂತರ ಬಳಕೆದಾರರನ್ನು ರಚಿಸಲು ಫಾರ್ಮ್ ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ಟೋಕನ್ ಅನ್ನು ಹೆಡರ್ ಆಗಿ ಕಳುಹಿಸಬೇಕು. ಅಂದರೆ, ಎರಡನೇ ವಿನಂತಿಯನ್ನು ಪೋಷಿಸಲು ನಾವು ಮೊದಲ ವಿನಂತಿಯ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಬಳಸುತ್ತೇವೆ. ಎಪಿಐ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಈ “ವಿನಂತಿಗಳ ಸರಪಳಿ” ತುಂಬಾ ಸಾಮಾನ್ಯವಾಗಿದೆ.
CreateUserScenario
package io.devqa.scenarios import io.devqa.requests.{CreateUserRequest, GetTokenRequest} import io.gatling.core.Predef.scenario object CreateUserScenario {
val createUserScenario = scenario('Create User Scenario')
.exec(GetTokenRequest.get_token)
.exec(CreateUserRequest.create_user) }
ಅಂತಿಮವಾಗಿ, ಸಿಮ್ಯುಲೇಶನ್ಸ್ ಪ್ಯಾಕೇಜ್ನಲ್ಲಿ ನಾವು ಸಿಮ್ಯುಲೇಶನ್ಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ. ನೀವು ಸಿಮ್ಯುಲೇಶನ್ಗಳನ್ನು ವಿಭಿನ್ನ ಲೋಡ್ ಪ್ರೊಫೈಲ್ಗಳಂತೆ ಯೋಚಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ನಾವು ಸಾಮಾನ್ಯ ಲೋಡ್ ಸಿಮ್ಯುಲೇಶನ್ ಅಥವಾ ಸ್ಪೈಕ್ ಸಿಮ್ಯುಲೇಶನ್ ಅನ್ನು ಹೊಂದಬಹುದು.
ಸಿಮ್ಯುಲೇಶನ್ಗಳು ಸ್ಕಲಾ ತರಗತಿಗಳಾಗಿರಬೇಕು ಮತ್ತು ಅವು ಗ್ಯಾಟ್ಲಿಂಗ್ ಸಿಮ್ಯುಲೇಶನ್ ವರ್ಗವನ್ನು ವಿಸ್ತರಿಸಬೇಕು.
package io.devqa.simulations import io.devqa.scenarios.CreateUserScenario import io.gatling.core.Predef.Simulation import io.gatling.core.Predef._ import io.devqa.config.Config._ class CreateUserSimulation extends Simulation {
private val createUserExec = CreateUserScenario.createUserScenario
.inject(atOnceUsers(users))
setUp(createUserExec) }
ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಈ ಕೆಳಗಿನಂತೆ ಇರಬೇಕು:
ರನ್ಟೈಮ್ನಲ್ಲಿ ನಮ್ಮ ಕಾರ್ಯಕ್ಷಮತೆ ಪರೀಕ್ಷೆಗಳಿಗೆ ಬಳಕೆದಾರರು ಮತ್ತು ಥ್ರೋಪುಟ್ನಂತಹ ನಿಯತಾಂಕಗಳನ್ನು ರವಾನಿಸಲು ನಾವು ನಮ್ಮ pom.xml ಫೈಲ್ ಅನ್ನು ಮಾರ್ಪಡಿಸಬೇಕಾಗಿದೆ.
Pom.xml ಫೈಲ್ ಹೀಗಿರಬೇಕು:
4.0.0
testing-excellence
gatling-framework
1.0-SNAPSHOT
1.8
1.8
UTF-8
2.3.0
2.2.4
1.3.2
CreateUserSimulation
io.gatling.highcharts
gatling-charts-highcharts
${gatling.version}
test
com.typesafe
config
${typesafe-config.version}
io.gatling
gatling-maven-plugin
${gatling-plugin.version}
io.devqa.simulations.${simulation}
-Denv=${env}
-Dusers=${users}
-Drampup=${rampup}
-Dduration=${duration}
-Dthroughput=${throughput}
true
ಅಂತಿಮವಾಗಿ, ಸಿಮ್ಯುಲೇಶನ್ ವರ್ಗವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು, ನಾವು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುತ್ತೇವೆ
mvn clean gatling:execute -Dusers=1
ಮೇಲಿನ ಆಜ್ಞೆಯು 1 ಬಳಕೆದಾರರೊಂದಿಗೆ CreateUserSimulation ಅನ್ನು ಚಾಲನೆ ಮಾಡುತ್ತದೆ.