OAuth 2.0 பியரர் டோக்கனைப் பயன்படுத்தி கேட்லிங் மூலம் அங்கீகாரம்

கேட்லிங் மூலம் Oauth2 அங்கீகாரத்தை எவ்வாறு செய்வது என்பதை இந்த இடுகை விளக்குகிறது.

இந்த எடுத்துக்காட்டில், ஒரு பயனரை உருவாக்க நாங்கள் ஒரு கோரிக்கையை அனுப்புகிறோம். இருப்பினும், பயனர் இறுதிப்புள்ளி பாதுகாக்கப்படுகிறது மற்றும் அணுகல்_டோகன் தேவைப்படுகிறது.

முதலில், ஒரு தாங்கி_டோகன் அல்லது அணுகல்_டோகனைப் பெறுவோம், பின்னர் பயனரை உருவாக்க அடுத்த ஏபிஐ கோரிக்கைக்கு தலைப்பாக அனுப்புவோம்.


இதை விளக்குவதற்கு, நாங்கள் முன்பு கட்டிய கேட்லிங்கிற்கான அதே திட்ட கட்டமைப்பைப் பயன்படுத்துவோம்:

கேட்லிங் மற்றும் மேவனுடன் செயல்திறன் சோதனை கட்டமைப்பு


மேற்கண்ட இடுகையில் உள்ள படிகளைப் பின்பற்றும்போது, ​​எங்கள் திட்ட கட்டமைப்பை பின்வருமாறு வைத்திருப்போம்:



உள்ளமைவில் அளவுருக்களை வரையறுத்தல்

முதலில் | _ _ + _ | இல் எங்கள் OAuth 2.0 அளவுருக்களை வரையறுக்கிறோம் பொருள் கோப்பு கட்டமைப்பு கோப்புறை:

Configuration.scalaகுறிப்பு:பொதுவாக, சோதனைகள் இயங்கும் கணினியில் சூழல், கிளையன்ட்_ஐடி மற்றும் கிளையன்ட்_செக்ரெட்டுகள் ஏற்றுமதி செய்யப்படுகின்றன, எனவே நாம் இதைப் பயன்படுத்தலாம் System.getProperty () மதிப்புகளைப் படிக்க.

கோரிக்கைகளை

ஒரு தாங்கி டோக்கனைப் பெற அங்கீகார சேவையகத்திற்கு கோரிக்கையை அனுப்பும் குறியீட்டை இப்போது எழுத வேண்டும்.


OAuth 2.0 கோரிக்கை - access_token

இந்த கோப்பு object Configuration { val environment: String = System.getProperty('environment') val clientId: String = System.getProperty('CLIENT_ID') val clientSecret: String = System.getProperty('CLIENT_SECRET') val apiURL: String = 'https://some-sub-domain.' + environment + 'some-domain.com/api' var tokenPath: String = 'https://some-sub-domain' + environment + '.eu.auth0.com/oauth/token' val userPath = '/identity/iaa/v1/users' } கீழ் சேமிக்கப்படுகிறது கோரிக்கைகளை எங்கள் திட்ட கட்டமைப்பில் கோப்புறை.

AuthRequest.scala

மேலே உள்ள குறியீடு துணுக்கில், அணுகல்_டோகனை ஒரு கோப்பில் சேமிக்கிறோம்.

மேலே உள்ள அழைப்பு, அணுகல்_டோகனைப் பெறுகிறது.

Access_token ஐ தலைப்பாக அனுப்புவதன் மூலம் பயனரை உருவாக்க எங்களுக்கு மற்றொரு கோரிக்கை தேவை.


பயனர் கோரிக்கை

எங்கள் பயனர் கோரிக்கை import java.io.{BufferedWriter, FileWriter} import config.Configuration import io.gatling.core.Predef._ import io.gatling.http.Predef._ object AuthRequest { val getAccessToken = exec(http('Get access token')
.post(Configuration.tokenPath)
.body(StringBody(
s'''{

'client_id': '${Configuration.clientId}',

'client_secret': '${Configuration.clientSecret}',

'audience': 'https://some-domain-name.com/user',

'grant_type': 'client_credentials',

'scope': 'user:admin'
}'''
))
.asJson
.headers(Map('Content-Type' -> 'application/json'))
.check(status.is(200))
.check(jsonPath('$.access_token').saveAs('access_token')))
.exec {
session =>
val fw = new BufferedWriter(new FileWriter('access_token.txt', true))
try {

fw.write(session('access_token').as[String] + ' ')
}
finally fw.close()
session
} }
என்ற கோப்பில் உள்ளது மற்றும் கீழ் சேமிக்கப்படுகிறது கோரிக்கைகளை கோப்புறை.

UserRequests.scala

காட்சி

இப்போது நாம் காட்சி பொருளை எழுதுகிறோம். இந்த எடுத்துக்காட்டில் எங்கள் பொருள் import config.Configuration.{apiURL, userPath} import io.gatling.core.Predef._ import io.gatling.http.Predef._ object UserRequests { private val auth0Headers = Map(
'Accept' -> 'application/json, text/javascript, */*; q=0.01',
'Content-Type' -> 'application/json',
'Authorization' -> 'Bearer ${access_token}') val createUser = exec(http('Create user')
.post(apiURL + userPath)
.headers(auth0Headers)
.body(ElFileBody('createUser.json'))
.check(status.is(201))) }
மற்றும் கீழ் சேமிக்கப்படுகிறது காட்சி கோப்புறை.

UserScenarios.scala

மேலே உள்ள கோரிக்கை, தலைப்பில் ஒரு தாங்கியாக அணுகல்_டோகன் மூலம் ஒரு பயனரை உருவாக்க ஒரு POST கோரிக்கையை அனுப்புகிறது.



உருவகப்படுத்துதல்

இறுதியாக எங்கள் உருவகப்படுத்துதல் கோப்பு import requests.{AuthRequest, UserRequests} import io.gatling.core.Predef._ object UserScenarios { var userIds:Array[Map[String,String]] =
(100 to 900).toArray map ( x => { Map( 'userId' -> x.toString) }) val getAccessToken = scenario('Get token')
.exec(AuthRequest.getAccessToken) val createUserScenario = scenario('Create user')
.feed(userIds.circular)
.exec(UserAuthZRequest.getAccessToken)
.exec(UserRequests.createUser) }
கீழ் சேமிக்கப்படுகிறது உருவகப்படுத்துதல்கள் கோப்புறை.


UserSimulation.scala

நாம் பயன்படுத்தும் சோதனைகளை இயக்க

import scenario.UserScenarios import io.gatling.core.Predef._ import scala.concurrent.duration._ class UserSimulation extends Simulation { setUp(
UserScenarios.createUserScenario.inject(rampUsers(250) during (15 minutes)), ) }

சுவாரசியமான கட்டுரைகள்