ಹಾಯ್!
G Suite ಬಳಕೆದಾರರನ್ನು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸಲು Google API ನೊಂದಿಗೆ PowerShell ಸಂವಹನದ ಅನುಷ್ಠಾನವನ್ನು ಈ ಲೇಖನವು ವಿವರಿಸುತ್ತದೆ.
ನಾವು ಸಂಸ್ಥೆಯಾದ್ಯಂತ ಹಲವಾರು ಆಂತರಿಕ ಮತ್ತು ಕ್ಲೌಡ್ ಸೇವೆಗಳನ್ನು ಬಳಸುತ್ತೇವೆ. ಬಹುಪಾಲು, ಅವುಗಳಲ್ಲಿ ದೃಢೀಕರಣವು Google ಅಥವಾ ಸಕ್ರಿಯ ಡೈರೆಕ್ಟರಿಗೆ ಬರುತ್ತದೆ, ಅದರ ನಡುವೆ ನಾವು ಪ್ರತಿಕೃತಿಯನ್ನು ನಿರ್ವಹಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ; ಅದರ ಪ್ರಕಾರ, ಹೊಸ ಉದ್ಯೋಗಿ ತೊರೆದಾಗ, ನೀವು ಈ ಎರಡು ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಖಾತೆಯನ್ನು ರಚಿಸಬೇಕು/ಸಕ್ರಿಯಗೊಳಿಸಬೇಕು. ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು, ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸುವ ಮತ್ತು ಎರಡೂ ಸೇವೆಗಳಿಗೆ ಕಳುಹಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆಯಲು ನಾವು ನಿರ್ಧರಿಸಿದ್ದೇವೆ.
ಅಧಿಕಾರ
ಅವಶ್ಯಕತೆಗಳನ್ನು ರಚಿಸುವಾಗ, ಅಧಿಕಾರಕ್ಕಾಗಿ ನಿಜವಾದ ಮಾನವ ನಿರ್ವಾಹಕರನ್ನು ಬಳಸಲು ನಾವು ನಿರ್ಧರಿಸಿದ್ದೇವೆ; ಇದು ಆಕಸ್ಮಿಕ ಅಥವಾ ಉದ್ದೇಶಪೂರ್ವಕ ಬೃಹತ್ ಬದಲಾವಣೆಗಳ ಸಂದರ್ಭದಲ್ಲಿ ಕ್ರಿಯೆಗಳ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.
Google APIಗಳು ದೃಢೀಕರಣ ಮತ್ತು ದೃಢೀಕರಣಕ್ಕಾಗಿ OAuth 2.0 ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಬಳಸುತ್ತವೆ. ಬಳಕೆಯ ಪ್ರಕರಣಗಳು ಮತ್ತು ಹೆಚ್ಚು ವಿವರವಾದ ವಿವರಣೆಗಳನ್ನು ಇಲ್ಲಿ ಕಾಣಬಹುದು: .
ಡೆಸ್ಕ್‌ಟಾಪ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ದೃಢೀಕರಣಕ್ಕಾಗಿ ಬಳಸಲಾಗುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ನಾನು ಆಯ್ಕೆ ಮಾಡಿದ್ದೇನೆ. ಸೇವಾ ಖಾತೆಯನ್ನು ಬಳಸಲು ಒಂದು ಆಯ್ಕೆಯೂ ಇದೆ, ಇದು ಬಳಕೆದಾರರಿಂದ ಅನಗತ್ಯ ಚಲನೆಗಳ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.
ಕೆಳಗಿನ ಚಿತ್ರವು Google ಪುಟದಿಂದ ಆಯ್ಕೆಮಾಡಿದ ಸನ್ನಿವೇಶದ ಸ್ಕೀಮ್ಯಾಟಿಕ್ ವಿವರಣೆಯಾಗಿದೆ.
- ಮೊದಲಿಗೆ, ನಾವು ಬಳಕೆದಾರರನ್ನು Google ಖಾತೆ ದೃಢೀಕರಣ ಪುಟಕ್ಕೆ ಕಳುಹಿಸುತ್ತೇವೆ, GET ನಿಯತಾಂಕಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತೇವೆ:
- ಅಪ್ಲಿಕೇಶನ್ ಐಡಿ
- ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಪ್ರವೇಶ ಅಗತ್ಯವಿರುವ ಪ್ರದೇಶಗಳು
- ಕಾರ್ಯವಿಧಾನವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ ಬಳಕೆದಾರರನ್ನು ಮರುನಿರ್ದೇಶಿಸಲಾಗುವ ವಿಳಾಸ
- ನಾವು ಟೋಕನ್ ಅನ್ನು ನವೀಕರಿಸುವ ವಿಧಾನ
- ಭದ್ರತಾ ಕೋಡ್
- ಪರಿಶೀಲನೆ ಕೋಡ್ ಪ್ರಸರಣ ಸ್ವರೂಪ
- ದೃಢೀಕರಣ ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಬಳಕೆದಾರರನ್ನು ಮೊದಲ ವಿನಂತಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಪುಟಕ್ಕೆ ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತದೆ, ದೋಷ ಅಥವಾ ದೃಢೀಕರಣ ಕೋಡ್ ಅನ್ನು GET ನಿಯತಾಂಕಗಳಿಂದ ರವಾನಿಸಲಾಗುತ್ತದೆ
- ಅಪ್ಲಿಕೇಶನ್ (ಸ್ಕ್ರಿಪ್ಟ್) ಈ ನಿಯತಾಂಕಗಳನ್ನು ಸ್ವೀಕರಿಸಬೇಕಾಗುತ್ತದೆ ಮತ್ತು ಕೋಡ್ ಸ್ವೀಕರಿಸಿದರೆ, ಟೋಕನ್‌ಗಳನ್ನು ಪಡೆಯಲು ಈ ಕೆಳಗಿನ ವಿನಂತಿಯನ್ನು ಮಾಡಿ
- ವಿನಂತಿಯು ಸರಿಯಾಗಿದ್ದರೆ, Google API ಹಿಂತಿರುಗಿಸುತ್ತದೆ:
- ನಾವು ವಿನಂತಿಗಳನ್ನು ಮಾಡಬಹುದಾದ ಪ್ರವೇಶ ಟೋಕನ್
- ಈ ಟೋಕನ್‌ನ ಮಾನ್ಯತೆಯ ಅವಧಿ
- ಪ್ರವೇಶ ಟೋಕನ್ ಅನ್ನು ರಿಫ್ರೆಶ್ ಮಾಡಲು ರಿಫ್ರೆಶ್ ಟೋಕನ್ ಅಗತ್ಯವಿದೆ.
ಮೊದಲು ನೀವು Google API ಕನ್ಸೋಲ್‌ಗೆ ಹೋಗಬೇಕು: , ಬಯಸಿದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಆಯ್ಕೆಮಾಡಿ ಮತ್ತು ರುಜುವಾತುಗಳ ವಿಭಾಗದಲ್ಲಿ ಕ್ಲೈಂಟ್ OAuth ಗುರುತಿಸುವಿಕೆಯನ್ನು ರಚಿಸಿ. ಅಲ್ಲಿ (ಅಥವಾ ನಂತರ, ರಚಿಸಿದ ಗುರುತಿಸುವಿಕೆಯ ಗುಣಲಕ್ಷಣಗಳಲ್ಲಿ) ನೀವು ಮರುನಿರ್ದೇಶನವನ್ನು ಅನುಮತಿಸುವ ವಿಳಾಸಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಇವು ವಿವಿಧ ಪೋರ್ಟ್‌ಗಳೊಂದಿಗೆ ಹಲವಾರು ಸ್ಥಳೀಯ ಹೋಸ್ಟ್ ನಮೂದುಗಳಾಗಿವೆ (ಕೆಳಗೆ ನೋಡಿ).
ಸ್ಕ್ರಿಪ್ಟ್ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಓದಲು ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿಸಲು, ನೀವು ಮೊದಲ ಹಂತಗಳನ್ನು ಪ್ರತ್ಯೇಕ ಕಾರ್ಯದಲ್ಲಿ ಪ್ರದರ್ಶಿಸಬಹುದು ಅದು ಪ್ರವೇಶವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಟೋಕನ್‌ಗಳನ್ನು ರಿಫ್ರೆಶ್ ಮಾಡುತ್ತದೆ:
$client_secret = 'Our Client Secret'
$client_id = 'Our Client ID'
function Get-GoogleAuthToken {
if (-not [System.Net.HttpListener]::IsSupported) {
"HttpListener is not supported."
exit 1
}
$codeverifier = -join ((65..90) + (97..122) + (48..57) + 45 + 46 + 95 + 126 |Get-Random -Count 60| % {[char]$_})
$hasher = new-object System.Security.Cryptography.SHA256Managed
$hashByteArray = $hasher.ComputeHash([System.Text.Encoding]::UTF8.GetBytes($codeverifier))
$base64 = ((([System.Convert]::ToBase64String($hashByteArray)).replace('=','')).replace('+','-')).replace('/','_')
$ports = @(10600,15084,39700,42847,65387,32079)
$port = $ports[(get-random -Minimum 0 -maximum 5)]
Write-Host "Start browser..."
Start-Process "https://accounts.google.com/o/oauth2/v2/auth?code_challenge_method=S256&code_challenge=$base64&access_type=offline&client_id=$client_id&redirect_uri=http://localhost:$port&response_type=code&scope=https://www.googleapis.com/auth/admin.directory.user https://www.googleapis.com/auth/admin.directory.group"
$listener = New-Object System.Net.HttpListener
$listener.Prefixes.Add("http://localhost:"+$port+'/')
try {$listener.Start()} catch {
"Unable to start listener."
exit 1
}
while (($code -eq $null)) {
$context = $listener.GetContext()
Write-Host "Connection accepted" -f 'mag'
$url = $context.Request.RawUrl
$code = $url.split('?')[1].split('=')[1].split('&')[0]
if ($url.split('?')[1].split('=')[0] -eq 'error') {
Write-Host "Error!"$code -f 'red'
$buffer = [System.Text.Encoding]::UTF8.GetBytes("Error!"+$code)
$context.Response.ContentLength64 = $buffer.Length
$context.Response.OutputStream.Write($buffer, 0, $buffer.Length)
$context.Response.OutputStream.Close()
$listener.Stop()
exit 1
}
$buffer = [System.Text.Encoding]::UTF8.GetBytes("Now you can close this browser tab.")
$context.Response.ContentLength64 = $buffer.Length
$context.Response.OutputStream.Write($buffer, 0, $buffer.Length)
$context.Response.OutputStream.Close()
$listener.Stop()
}
Return Invoke-RestMethod -Method Post -Uri "https://www.googleapis.com/oauth2/v4/token" -Body @{
code = $code
client_id = $client_id
client_secret = $client_secret
redirect_uri = 'http://localhost:'+$port
grant_type = 'authorization_code'
code_verifier = $codeverifier
}
$code = $null
OAuth ಕ್ಲೈಂಟ್ ಐಡೆಂಟಿಫೈಯರ್ ಗುಣಲಕ್ಷಣಗಳಲ್ಲಿ ಪಡೆದ ಕ್ಲೈಂಟ್ ಐಡಿ ಮತ್ತು ಕ್ಲೈಂಟ್ ರಹಸ್ಯವನ್ನು ನಾವು ಹೊಂದಿಸಿದ್ದೇವೆ ಮತ್ತು ಕೋಡ್ ಪರಿಶೀಲಕವು 43 ರಿಂದ 128 ಅಕ್ಷರಗಳ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದ್ದು ಅದು ಕಾಯ್ದಿರಿಸದ ಅಕ್ಷರಗಳಿಂದ ಯಾದೃಚ್ಛಿಕವಾಗಿ ರಚಿಸಲ್ಪಡಬೇಕು: [AZ] / [az] / [0-9 ] / "-" / "." / "_" / "~".
ನಂತರ ಈ ಕೋಡ್ ಮತ್ತೆ ರವಾನೆಯಾಗುತ್ತದೆ. ಬಳಕೆದಾರರ ದೃಢೀಕರಣದ ನಂತರ ಮರುನಿರ್ದೇಶನವಾಗಿ ಹಿಂತಿರುಗಿದ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಆಕ್ರಮಣಕಾರರು ತಡೆಯಬಹುದಾದ ದುರ್ಬಲತೆಯನ್ನು ಇದು ನಿವಾರಿಸುತ್ತದೆ.
ನೀವು ಪ್ರಸ್ತುತ ವಿನಂತಿಯಲ್ಲಿ ಸ್ಪಷ್ಟ ಪಠ್ಯದಲ್ಲಿ ಕೋಡ್ ಪರಿಶೀಲಕವನ್ನು ಕಳುಹಿಸಬಹುದು (ಇದು ಅರ್ಥಹೀನವಾಗಿಸುತ್ತದೆ - ಇದು SHA256 ಅನ್ನು ಬೆಂಬಲಿಸದ ಸಿಸ್ಟಮ್‌ಗಳಿಗೆ ಮಾತ್ರ ಸೂಕ್ತವಾಗಿದೆ), ಅಥವಾ SHA256 ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಹ್ಯಾಶ್ ಅನ್ನು ರಚಿಸುವ ಮೂಲಕ, ಅದನ್ನು BASE64Url ನಲ್ಲಿ ಎನ್ಕೋಡ್ ಮಾಡಬೇಕು (ವಿಭಿನ್ನ Base64 ರಿಂದ ಎರಡು ಟೇಬಲ್ ಅಕ್ಷರಗಳಿಂದ) ಮತ್ತು ಅಕ್ಷರ ಸಾಲಿನ ಅಂತ್ಯಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು: =.
ಮುಂದೆ, ದೃಢೀಕರಣದ ನಂತರ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಸ್ವೀಕರಿಸಲು ನಾವು ಸ್ಥಳೀಯ ಗಣಕದಲ್ಲಿ http ಕೇಳಲು ಪ್ರಾರಂಭಿಸಬೇಕು, ಅದನ್ನು ಮರುನಿರ್ದೇಶನವಾಗಿ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.
ಆಡಳಿತಾತ್ಮಕ ಕಾರ್ಯಗಳನ್ನು ವಿಶೇಷ ಸರ್ವರ್‌ನಲ್ಲಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ, ಹಲವಾರು ನಿರ್ವಾಹಕರು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರನ್ ಮಾಡುವ ಸಾಧ್ಯತೆಯನ್ನು ನಾವು ತಳ್ಳಿಹಾಕಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದ್ದರಿಂದ ಇದು ಪ್ರಸ್ತುತ ಬಳಕೆದಾರರಿಗೆ ಯಾದೃಚ್ಛಿಕವಾಗಿ ಪೋರ್ಟ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ, ಆದರೆ ನಾನು ಪೂರ್ವನಿರ್ಧರಿತ ಪೋರ್ಟ್‌ಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದೆ ಅವುಗಳನ್ನು API ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ನಂಬುವಂತೆ ಸೇರಿಸಬೇಕು.
access_type=ಆಫ್‌ಲೈನ್ ಬ್ರೌಸರ್‌ನೊಂದಿಗೆ ಬಳಕೆದಾರರ ಸಂವಹನವಿಲ್ಲದೆಯೇ ಅಪ್ಲಿಕೇಶನ್ ಅವಧಿ ಮೀರಿದ ಟೋಕನ್ ಅನ್ನು ತನ್ನದೇ ಆದ ಮೇಲೆ ನವೀಕರಿಸಬಹುದು,
ಪ್ರತಿಕ್ರಿಯೆ_ಪ್ರಕಾರ = ಕೋಡ್ ಕೋಡ್ ಅನ್ನು ಹೇಗೆ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ ಎಂಬುದರ ಸ್ವರೂಪವನ್ನು ಹೊಂದಿಸುತ್ತದೆ (ಹಳೆಯ ಅಧಿಕಾರ ವಿಧಾನದ ಉಲ್ಲೇಖ, ಬಳಕೆದಾರರು ಬ್ರೌಸರ್‌ನಿಂದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಕೋಡ್ ಅನ್ನು ನಕಲಿಸಿದಾಗ),
ವ್ಯಾಪ್ತಿ ಪ್ರವೇಶದ ವ್ಯಾಪ್ತಿ ಮತ್ತು ಪ್ರಕಾರವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಅವುಗಳನ್ನು ಸ್ಪೇಸ್‌ಗಳು ಅಥವಾ %20 (URL ಎನ್ಕೋಡಿಂಗ್ ಪ್ರಕಾರ) ಮೂಲಕ ಬೇರ್ಪಡಿಸಬೇಕು. ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಪ್ರವೇಶ ಪ್ರದೇಶಗಳ ಪಟ್ಟಿಯನ್ನು ಇಲ್ಲಿ ನೋಡಬಹುದು: .
ಅಧಿಕೃತ ಕೋಡ್ ಸ್ವೀಕರಿಸಿದ ನಂತರ, ಅಪ್ಲಿಕೇಶನ್ ಬ್ರೌಸರ್‌ಗೆ ನಿಕಟ ಸಂದೇಶವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಪೋರ್ಟ್‌ನಲ್ಲಿ ಆಲಿಸುವುದನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ ಮತ್ತು ಟೋಕನ್ ಪಡೆಯಲು POST ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸುತ್ತದೆ. ಕನ್ಸೋಲ್ API ನಿಂದ ಹಿಂದೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಐಡಿ ಮತ್ತು ರಹಸ್ಯವನ್ನು ನಾವು ಅದರಲ್ಲಿ ಸೂಚಿಸುತ್ತೇವೆ, ಬಳಕೆದಾರರನ್ನು ಮರುನಿರ್ದೇಶಿಸುವ ವಿಳಾಸ ಮತ್ತು ಪ್ರೋಟೋಕಾಲ್ ವಿವರಣೆಗೆ ಅನುಗುಣವಾಗಿ ಅನುದಾನ_ಟೈಪ್ ಮಾಡಿ.
ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ, ನಾವು ಪ್ರವೇಶ ಟೋಕನ್, ಅದರ ಮಾನ್ಯತೆಯ ಅವಧಿಯನ್ನು ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಮತ್ತು ರಿಫ್ರೆಶ್ ಟೋಕನ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ, ಅದರೊಂದಿಗೆ ನಾವು ಪ್ರವೇಶ ಟೋಕನ್ ಅನ್ನು ನವೀಕರಿಸಬಹುದು.
ಅಪ್ಲಿಕೇಶನ್ ದೀರ್ಘ ಶೆಲ್ಫ್ ಜೀವಿತಾವಧಿಯೊಂದಿಗೆ ಸುರಕ್ಷಿತ ಸ್ಥಳದಲ್ಲಿ ಟೋಕನ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಬೇಕು, ಆದ್ದರಿಂದ ನಾವು ಸ್ವೀಕರಿಸಿದ ಪ್ರವೇಶವನ್ನು ಹಿಂತೆಗೆದುಕೊಳ್ಳುವವರೆಗೆ, ಅಪ್ಲಿಕೇಶನ್ ರಿಫ್ರೆಶ್ ಟೋಕನ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವುದಿಲ್ಲ. ಕೊನೆಯಲ್ಲಿ, ಟೋಕನ್ ಅನ್ನು ಹಿಂತೆಗೆದುಕೊಳ್ಳಲು ನಾನು ವಿನಂತಿಯನ್ನು ಸೇರಿಸಿದೆ; ಅಪ್ಲಿಕೇಶನ್ ಯಶಸ್ವಿಯಾಗಿ ಪೂರ್ಣಗೊಳ್ಳದಿದ್ದರೆ ಮತ್ತು ರಿಫ್ರೆಶ್ ಟೋಕನ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸದಿದ್ದರೆ, ಅದು ಮತ್ತೆ ಕಾರ್ಯವಿಧಾನವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ (ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಸ್ಥಳೀಯವಾಗಿ ಟೋಕನ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದು ಅಸುರಕ್ಷಿತ ಎಂದು ನಾವು ಪರಿಗಣಿಸಿದ್ದೇವೆ ಮತ್ತು ನಾವು ಮಾಡಬೇಡಿ ಕ್ರಿಪ್ಟೋಗ್ರಫಿಯೊಂದಿಗೆ ವಿಷಯಗಳನ್ನು ಸಂಕೀರ್ಣಗೊಳಿಸಲು ಅಥವಾ ಬ್ರೌಸರ್ ಅನ್ನು ಆಗಾಗ್ಗೆ ತೆರೆಯಲು ಬಯಸುವುದಿಲ್ಲ).
do {
$token_result = Get-GoogleAuthToken
$token = $token_result.access_token
if ($token_result.refresh_token -eq $null) {
Write-Host ("Session is not destroyed. Revoking token...")
Invoke-WebRequest -Uri ("https://accounts.google.com/o/oauth2/revoke?token="+$token)
}
} while ($token_result.refresh_token -eq $null)
$refresh_token = $token_result.refresh_token
$minute = ([int]("{0:mm}" -f ([timespan]::fromseconds($token_result.expires_in))))+((Get-date).Minute)-2
if ($minute -lt 0) {$minute += 60}
elseif ($minute -gt 59) {$minute -=60}
$token_expire = @{
hour = ([int]("{0:hh}" -f ([timespan]::fromseconds($token_result.expires_in))))+((Get-date).Hour)
minute = $minute
}
ನೀವು ಈಗಾಗಲೇ ಗಮನಿಸಿದಂತೆ, ಟೋಕನ್ ಅನ್ನು ಹಿಂತೆಗೆದುಕೊಳ್ಳುವಾಗ, Invoke-WebRequest ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಇನ್ವೋಕ್-ರೆಸ್ಟ್‌ಮೆಥಡ್‌ನಂತಲ್ಲದೆ, ಇದು ಸ್ವೀಕರಿಸಿದ ಡೇಟಾವನ್ನು ಬಳಸಬಹುದಾದ ಸ್ವರೂಪದಲ್ಲಿ ಹಿಂತಿರುಗಿಸುವುದಿಲ್ಲ ಮತ್ತು ವಿನಂತಿಯ ಸ್ಥಿತಿಯನ್ನು ತೋರಿಸುತ್ತದೆ.
ಮುಂದೆ, ಲಾಗಿನ್ + ಇಮೇಲ್ ಅನ್ನು ರಚಿಸುವ ಮೂಲಕ ಬಳಕೆದಾರರ ಮೊದಲ ಮತ್ತು ಕೊನೆಯ ಹೆಸರನ್ನು ನಮೂದಿಸಲು ಸ್ಕ್ರಿಪ್ಟ್ ನಿಮ್ಮನ್ನು ಕೇಳುತ್ತದೆ.
ವಿನಂತಿಗಳನ್ನು
ಮುಂದಿನ ವಿನಂತಿಗಳು - ಮೊದಲನೆಯದಾಗಿ, ಹೊಸದನ್ನು ರಚಿಸುವ ಅಥವಾ ಪ್ರಸ್ತುತವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವ ನಿರ್ಧಾರವನ್ನು ಪಡೆಯಲು ಅದೇ ಲಾಗಿನ್ ಹೊಂದಿರುವ ಬಳಕೆದಾರರು ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದಾರೆಯೇ ಎಂದು ನೀವು ಪರಿಶೀಲಿಸಬೇಕು.
ಸ್ವಿಚ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಆಯ್ಕೆಯೊಂದಿಗೆ ಒಂದು ಕಾರ್ಯದ ಸ್ವರೂಪದಲ್ಲಿ ಎಲ್ಲಾ ವಿನಂತಿಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಾನು ನಿರ್ಧರಿಸಿದೆ:
function GoogleQuery {
param (
$type,
$query
)
switch ($type) {
"SearchAccount" {
Return Invoke-RestMethod -Method Get -Uri "https://www.googleapis.com/admin/directory/v1/users" -Headers @{Authorization = "Bearer "+(Get-GoogleToken)} -Body @{
domain = 'rocketguys.com'
query = "email:$query"
}
}
"UpdateAccount" {
$body = @{
name = @{
givenName = $query['givenName']
familyName = $query['familyName']
}
suspended = 'false'
password = $query['password']
changePasswordAtNextLogin = 'true'
phones = @(@{
primary = 'true'
value = $query['phone']
type = "mobile"
})
orgUnitPath = $query['orgunit']
}
Return Invoke-RestMethod -Method Put -Uri ("https://www.googleapis.com/admin/directory/v1/users/"+$query['email']) -Headers @{Authorization = "Bearer "+(Get-GoogleToken)} -Body (ConvertTo-Json $body) -ContentType 'application/json; charset=utf-8'
}
"CreateAccount" {
$body = @{
primaryEmail = $query['email']
name = @{
givenName = $query['givenName']
familyName = $query['familyName']
}
suspended = 'false'
password = $query['password']
changePasswordAtNextLogin = 'true'
phones = @(@{
primary = 'true'
value = $query['phone']
type = "mobile"
})
orgUnitPath = $query['orgunit']
}
Return Invoke-RestMethod -Method Post -Uri "https://www.googleapis.com/admin/directory/v1/users" -Headers @{Authorization = "Bearer "+(Get-GoogleToken)} -Body (ConvertTo-Json $body) -ContentType 'application/json; charset=utf-8'
}
"AddMember" {
$body = @{
userKey = $query['email']
}
$ifrequest = Invoke-RestMethod -Method Get -Uri "https://www.googleapis.com/admin/directory/v1/groups" -Headers @{Authorization = "Bearer "+(Get-GoogleToken)} -Body $body
$array = @()
foreach ($group in $ifrequest.groups) {$array += $group.email}
if ($array -notcontains $query['groupkey']) {
$body = @{
email = $query['email']
role = "MEMBER"
}
Return Invoke-RestMethod -Method Post -Uri ("https://www.googleapis.com/admin/directory/v1/groups/"+$query['groupkey']+"/members") -Headers @{Authorization = "Bearer "+(Get-GoogleToken)} -Body (ConvertTo-Json $body) -ContentType 'application/json; charset=utf-8'
} else {
Return ($query['email']+" now is a member of "+$query['groupkey'])
}
}
}
}ಪ್ರತಿ ವಿನಂತಿಯಲ್ಲಿ, ನೀವು ಟೋಕನ್ ಪ್ರಕಾರ ಮತ್ತು ಪ್ರವೇಶ ಟೋಕನ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಅಧಿಕೃತ ಹೆಡರ್ ಅನ್ನು ಕಳುಹಿಸಬೇಕಾಗುತ್ತದೆ. ಪ್ರಸ್ತುತ, ಟೋಕನ್ ಪ್ರಕಾರವು ಯಾವಾಗಲೂ ಬೇರರ್ ಆಗಿದೆ. ಏಕೆಂದರೆ ಟೋಕನ್ ಅವಧಿ ಮುಗಿದಿಲ್ಲ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸಬೇಕಾಗಿದೆ ಮತ್ತು ಅದನ್ನು ನೀಡಿದ ಕ್ಷಣದಿಂದ ಒಂದು ಗಂಟೆಯ ನಂತರ ಅದನ್ನು ನವೀಕರಿಸಬೇಕು, ಪ್ರವೇಶ ಟೋಕನ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುವ ಮತ್ತೊಂದು ಕಾರ್ಯಕ್ಕಾಗಿ ನಾನು ವಿನಂತಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ್ದೇನೆ. ಮೊದಲ ಪ್ರವೇಶ ಟೋಕನ್ ಅನ್ನು ಸ್ವೀಕರಿಸುವಾಗ ಅದೇ ಕೋಡ್ ತುಣುಕು ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪ್ರಾರಂಭದಲ್ಲಿದೆ:
function Get-GoogleToken {
if (((Get-date).Hour -gt $token_expire.hour) -or (((Get-date).Hour -ge $token_expire.hour) -and ((Get-date).Minute -gt $token_expire.minute))) {
Write-Host "Token Expired. Refreshing..."
$request = (Invoke-RestMethod -Method Post -Uri "https://www.googleapis.com/oauth2/v4/token" -ContentType 'application/x-www-form-urlencoded' -Body @{
client_id = $client_id
client_secret = $client_secret
refresh_token = $refresh_token
grant_type = 'refresh_token'
})
$token = $request.access_token
$minute = ([int]("{0:mm}" -f ([timespan]::fromseconds($request.expires_in))))+((Get-date).Minute)-2
if ($minute -lt 0) {$minute += 60}
elseif ($minute -gt 59) {$minute -=60}
$script:token_expire = @{
hour = ([int]("{0:hh}" -f ([timespan]::fromseconds($request.expires_in))))+((Get-date).Hour)
minute = $minute
}
}
return $token
}ಅಸ್ತಿತ್ವಕ್ಕಾಗಿ ಲಾಗಿನ್ ಅನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ:
function Check_Google {
$query = (GoogleQuery 'SearchAccount' $username)
if ($query.users -ne $null) {
$user = $query.users[0]
Write-Host $user.name.fullName' - '$user.PrimaryEmail' - suspended: '$user.Suspended
$GAresult = $user
}
if ($GAresult) {
$return = $GAresult
} else {$return = 'gg'}
return $return
}ಇಮೇಲ್:$query ವಿನಂತಿಯು ಅಲಿಯಾಸ್‌ಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ನಿಖರವಾಗಿ ಆ ಇಮೇಲ್‌ನೊಂದಿಗೆ ಬಳಕೆದಾರರನ್ನು ಹುಡುಕಲು API ಅನ್ನು ಕೇಳುತ್ತದೆ. ನೀವು ವೈಲ್ಡ್ಕಾರ್ಡ್ ಅನ್ನು ಸಹ ಬಳಸಬಹುದು: =, :, :{PREFIX}*.
ಡೇಟಾವನ್ನು ಪಡೆಯಲು, GET ವಿನಂತಿ ವಿಧಾನವನ್ನು ಬಳಸಿ, ಡೇಟಾವನ್ನು ಸೇರಿಸಲು (ಖಾತೆಯನ್ನು ರಚಿಸುವುದು ಅಥವಾ ಗುಂಪಿಗೆ ಸದಸ್ಯರನ್ನು ಸೇರಿಸುವುದು) - POST, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಡೇಟಾವನ್ನು ನವೀಕರಿಸಲು - PUT, ದಾಖಲೆಯನ್ನು ಅಳಿಸಲು (ಉದಾಹರಣೆಗೆ, ಗುಂಪಿನಿಂದ ಸದಸ್ಯ) - ಅಳಿಸು.
ಸ್ಕ್ರಿಪ್ಟ್ ಫೋನ್ ಸಂಖ್ಯೆಯನ್ನು (ಅಮಾನ್ಯಗೊಳಿಸದ ಸ್ಟ್ರಿಂಗ್) ಮತ್ತು ಪ್ರಾದೇಶಿಕ ವಿತರಣಾ ಗುಂಪಿನಲ್ಲಿ ಸೇರಿಸಲು ಸಹ ಕೇಳುತ್ತದೆ. ಆಯ್ಕೆಮಾಡಿದ ಸಕ್ರಿಯ ಡೈರೆಕ್ಟರಿ OU ಅನ್ನು ಆಧರಿಸಿ ಬಳಕೆದಾರರು ಯಾವ ಸಾಂಸ್ಥಿಕ ಘಟಕವನ್ನು ಹೊಂದಿರಬೇಕು ಎಂಬುದನ್ನು ಇದು ನಿರ್ಧರಿಸುತ್ತದೆ ಮತ್ತು ಪಾಸ್‌ವರ್ಡ್‌ನೊಂದಿಗೆ ಬರುತ್ತದೆ:
do {
$phone = Read-Host "Телефон в формате +7хххххххх"
} while (-not $phone)
do {
$moscow = Read-Host "В Московский офис? (y/n) "
} while (-not (($moscow -eq 'y') -or ($moscow -eq 'n')))
$orgunit = '/'
if ($OU -like "*OU=Delivery,OU=Users,OU=ROOT,DC=rocket,DC=local") {
Write-host "Будет создана в /Team delivery"
$orgunit = "/Team delivery"
}
$Password = -join ( 48..57 + 65..90 + 97..122 | Get-Random -Count 12 | % {[char]$_})+"*Ba"
ತದನಂತರ ಅವನು ಖಾತೆಯನ್ನು ಕುಶಲತೆಯಿಂದ ಪ್ರಾರಂಭಿಸುತ್ತಾನೆ:
$query = @{
email = $email
givenName = $firstname
familyName = $lastname
password = $password
phone = $phone
orgunit = $orgunit
}
if ($GMailExist) {
Write-Host "Запускаем изменение аккаунта" -f mag
(GoogleQuery 'UpdateAccount' $query) | fl
write-host "Не забудь проверить группы у включенного $Username в Google."
} else {
Write-Host "Запускаем создание аккаунта" -f mag
(GoogleQuery 'CreateAccount' $query) | fl
}
if ($moscow -eq "y"){
write-host "Добавляем в группу moscowoffice"
$query = @{
groupkey = '[email protected]'
email = $email
}
(GoogleQuery 'AddMember' $query) | fl
}
ಖಾತೆಯನ್ನು ನವೀಕರಿಸುವ ಮತ್ತು ರಚಿಸುವ ಕಾರ್ಯಗಳು ಒಂದೇ ರೀತಿಯ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಹೊಂದಿವೆ; ಎಲ್ಲಾ ಹೆಚ್ಚುವರಿ ಕ್ಷೇತ್ರಗಳ ಅಗತ್ಯವಿಲ್ಲ; ಫೋನ್ ಸಂಖ್ಯೆಗಳೊಂದಿಗಿನ ವಿಭಾಗದಲ್ಲಿ, ಸಂಖ್ಯೆ ಮತ್ತು ಅದರ ಪ್ರಕಾರದೊಂದಿಗೆ ಒಂದು ದಾಖಲೆಯನ್ನು ಒಳಗೊಂಡಿರುವ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕಾಗುತ್ತದೆ.
ಬಳಕೆದಾರರನ್ನು ಗುಂಪಿಗೆ ಸೇರಿಸುವಾಗ ದೋಷವನ್ನು ಸ್ವೀಕರಿಸದಿರಲು, ಗುಂಪಿನ ಸದಸ್ಯರ ಪಟ್ಟಿಯನ್ನು ಅಥವಾ ಸಂಯೋಜನೆಯನ್ನು ಬಳಕೆದಾರರಿಂದ ಪಡೆಯುವ ಮೂಲಕ ನಾವು ಮೊದಲು ಅವರು ಈಗಾಗಲೇ ಈ ಗುಂಪಿನ ಸದಸ್ಯರಾಗಿದ್ದಾರೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಬಹುದು.
ನಿರ್ದಿಷ್ಟ ಬಳಕೆದಾರರ ಗುಂಪಿನ ಸದಸ್ಯತ್ವವನ್ನು ಪ್ರಶ್ನಿಸುವುದು ಪುನರಾವರ್ತಿತವಾಗಿರುವುದಿಲ್ಲ ಮತ್ತು ನೇರ ಸದಸ್ಯತ್ವವನ್ನು ಮಾತ್ರ ತೋರಿಸುತ್ತದೆ. ಈಗಾಗಲೇ ಮಕ್ಕಳ ಗುಂಪನ್ನು ಹೊಂದಿರುವ ಪೋಷಕ ಗುಂಪಿನಲ್ಲಿ ಬಳಕೆದಾರರನ್ನು ಸೇರಿಸುವುದು ಯಶಸ್ವಿಯಾಗುತ್ತದೆ.
ತೀರ್ಮಾನಕ್ಕೆ
ಹೊಸ ಖಾತೆಗಾಗಿ ಪಾಸ್ವರ್ಡ್ ಅನ್ನು ಬಳಕೆದಾರರಿಗೆ ಕಳುಹಿಸುವುದು ಮಾತ್ರ ಉಳಿದಿದೆ. ನಾವು ಇದನ್ನು SMS ಮೂಲಕ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಸೂಚನೆಗಳೊಂದಿಗೆ ಸಾಮಾನ್ಯ ಮಾಹಿತಿಯನ್ನು ಕಳುಹಿಸುತ್ತೇವೆ ಮತ್ತು ವೈಯಕ್ತಿಕ ಇಮೇಲ್‌ಗೆ ಲಾಗಿನ್ ಮಾಡಿ, ಅದನ್ನು ಫೋನ್ ಸಂಖ್ಯೆಯ ಜೊತೆಗೆ ನೇಮಕಾತಿ ವಿಭಾಗವು ಒದಗಿಸಿದೆ. ಪರ್ಯಾಯವಾಗಿ, ನೀವು ಹಣವನ್ನು ಉಳಿಸಬಹುದು ಮತ್ತು ನಿಮ್ಮ ಪಾಸ್ವರ್ಡ್ ಅನ್ನು ರಹಸ್ಯ ಟೆಲಿಗ್ರಾಮ್ ಚಾಟ್‌ಗೆ ಕಳುಹಿಸಬಹುದು, ಇದನ್ನು ಎರಡನೇ ಅಂಶವೆಂದು ಪರಿಗಣಿಸಬಹುದು (ಮ್ಯಾಕ್‌ಬುಕ್ಸ್ ಒಂದು ಅಪವಾದವಾಗಿರುತ್ತದೆ).
ಕೊನೆಯವರೆಗೂ ಓದಿದ್ದಕ್ಕಾಗಿ ಧನ್ಯವಾದಗಳು. ಲೇಖನಗಳನ್ನು ಬರೆಯುವ ಶೈಲಿಯನ್ನು ಸುಧಾರಿಸಲು ಸಲಹೆಗಳನ್ನು ನೋಡಲು ನಾನು ಸಂತೋಷಪಡುತ್ತೇನೆ ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬರೆಯುವಾಗ ನೀವು ಕಡಿಮೆ ದೋಷಗಳನ್ನು ಹಿಡಿಯಲು ಬಯಸುತ್ತೇನೆ =)
ವಿಷಯಾಧಾರಿತವಾಗಿ ಉಪಯುಕ್ತ ಅಥವಾ ಸರಳವಾಗಿ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸಬಹುದಾದ ಲಿಂಕ್‌ಗಳ ಪಟ್ಟಿ:
ಮೂಲ: www.habr.com