PowerCLI સ્ક્રિપ્ટ્સ માટે રોકેટ બૂસ્ટર કેવી રીતે બનાવવું 

વહેલા કે પછીથી, કોઈપણ VMware સિસ્ટમ એડમિનિસ્ટ્રેટર નિયમિત કાર્યોને સ્વચાલિત કરવા માટે આવે છે. તે બધું કમાન્ડ લાઇનથી શરૂ થાય છે, પછી પાવરશેલ અથવા VMware PowerCLI આવે છે.

ચાલો કહીએ કે તમે ISE શરૂ કરવા અને "અમુક પ્રકારના જાદુ" ને કારણે કામ કરતા મોડ્યુલોમાંથી પ્રમાણભૂત cmdletsનો ઉપયોગ કરતાં થોડી વધુ આગળ પાવરશેલમાં નિપુણતા મેળવી છે. જ્યારે તમે વર્ચ્યુઅલ મશીનોને સેંકડોમાં ગણવાનું શરૂ કરશો, ત્યારે તમે જોશો કે નાના સ્કેલ પર મદદ કરતી સ્ક્રિપ્ટો મોટા પાયે નોંધપાત્ર રીતે ધીમી ચાલે છે. 

આ સ્થિતિમાં, 2 સાધનો મદદ કરશે:

• પાવરશેલ રનસ્પેસ - એક અભિગમ જે તમને અલગ થ્રેડોમાં પ્રક્રિયાઓના અમલને સમાંતર બનાવવા દે છે; 
• ગેટ-વ્યૂ - મૂળભૂત PowerCLI ફંક્શન, Windows માં Get-WMIObject નું એનાલોગ. આ cmdlet એકમોની સાથેની વસ્તુઓને ખેંચતું નથી, પરંતુ સાદા ડેટા પ્રકારો સાથે સાદા ઓબ્જેક્ટના રૂપમાં માહિતી મેળવે છે. ઘણા કિસ્સાઓમાં તે ઝડપથી બહાર આવે છે.

આગળ, હું દરેક ટૂલ વિશે ટૂંકમાં વાત કરીશ અને ઉપયોગનાં ઉદાહરણો બતાવીશ. ચાલો ચોક્કસ સ્ક્રિપ્ટ્સનું વિશ્લેષણ કરીએ અને જોઈએ કે જ્યારે એક બીજી કરતાં વધુ સારી રીતે કામ કરે છે. જાઓ!

પ્રથમ તબક્કો: રનસ્પેસ

તેથી, રનસ્પેસ મુખ્ય મોડ્યુલની બહારના કાર્યોની સમાંતર પ્રક્રિયા માટે રચાયેલ છે. અલબત્ત, તમે બીજી પ્રક્રિયા શરૂ કરી શકો છો જે થોડી મેમરી, પ્રોસેસર વગેરે ખાઈ જશે. જો તમારી સ્ક્રિપ્ટ થોડી મિનિટોમાં ચાલે છે અને એક ગીગાબાઈટ મેમરી વાપરે છે, તો સંભવતઃ તમારે રનસ્પેસની જરૂર નહીં પડે. પરંતુ હજારો ઑબ્જેક્ટ્સ માટેની સ્ક્રિપ્ટો માટે તે જરૂરી છે.

તમે અહીં શીખવાનું શરૂ કરી શકો છો: 
પાવરશેલ રનસ્પેસનો ઉપયોગ શરૂ કરવો: ભાગ 1

રનસ્પેસનો ઉપયોગ શું આપે છે:

• એક્ઝિક્યુટેડ આદેશોની સૂચિને મર્યાદિત કરીને ઝડપ,
• કાર્યોનો સમાંતર અમલ,
• સલામતી.

જ્યારે રનસ્પેસ મદદ કરે છે ત્યારે ઇન્ટરનેટ પરથી અહીં એક ઉદાહરણ છે:

"સંગ્રહ વિવાદ એ vSphere માં ટ્રૅક કરવા માટેનું સૌથી મુશ્કેલ મેટ્રિક્સ છે. vCenter ની અંદર, તમે માત્ર જઈને જોઈ શકતા નથી કે કઈ VM વધુ સ્ટોરેજ સંસાધનોનો ઉપયોગ કરી રહી છે. સદભાગ્યે, તમે પાવરશેલને આભારી મિનિટોમાં આ ડેટા એકત્રિત કરી શકો છો.
હું એક સ્ક્રિપ્ટ શેર કરીશ જે VMware સિસ્ટમ એડમિનિસ્ટ્રેટર્સને સમગ્ર vCenterમાં ઝડપથી શોધવાની અને તેમના સરેરાશ વપરાશ પરના ડેટા સાથે VM ની સૂચિ પ્રાપ્ત કરવાની મંજૂરી આપશે.  
સ્ક્રિપ્ટ પાવરશેલ રનસ્પેસનો ઉપયોગ કરે છે જેથી દરેક ESXi હોસ્ટને તેના પોતાના VM માંથી અલગ રનસ્પેસમાં વપરાશની માહિતી એકત્રિત કરી શકાય અને તરત જ પૂર્ણતાની જાણ કરી શકાય. આ પાવરશેલને યજમાનો દ્વારા પુનરાવર્તિત કરવા અને દરેકની વિનંતી પૂર્ણ કરવાની રાહ જોવાને બદલે તરત જ નોકરીઓ બંધ કરવાની મંજૂરી આપે છે."

સોર્સ: ESXi ડેશબોર્ડ પર વર્ચ્યુઅલ મશીન I/O કેવી રીતે બતાવવું

નીચેના કિસ્સામાં, રનસ્પેસ હવે ઉપયોગી નથી:

“હું એક સ્ક્રિપ્ટ લખવાનો પ્રયાસ કરી રહ્યો છું જે VM માંથી ઘણો ડેટા એકત્રિત કરે છે અને જ્યારે જરૂરી હોય ત્યારે નવો ડેટા લખે છે. સમસ્યા એ છે કે ત્યાં ઘણા બધા VM છે, અને એક મશીન પર 5-8 સેકન્ડ ખર્ચવામાં આવે છે." 

સોર્સ: RunspacePool સાથે મલ્ટિથ્રેડિંગ PowerCLI

અહીં તમારે ગેટ-વ્યૂની જરૂર પડશે, ચાલો તેના પર આગળ વધીએ. 

બીજો તબક્કો: ગેટ-વ્યૂ

ગેટ-વ્યૂ શા માટે ઉપયોગી છે તે સમજવા માટે, સામાન્ય રીતે cmdlets કેવી રીતે કાર્ય કરે છે તે યાદ રાખવું યોગ્ય છે. 

API સંદર્ભ પુસ્તકોનો અભ્યાસ કર્યા વિના અને આગલા ચક્રને પુનઃશોધ કર્યા વિના સરળતાપૂર્વક માહિતી મેળવવા માટે Cmdletsની જરૂર છે. જૂના દિવસોમાં કોડની સો કે બે લીટીઓ શું લેતી હતી, પાવરશેલ તમને એક આદેશ સાથે કરવાની પરવાનગી આપે છે. અમે ઝડપ સાથે આ સુવિધા માટે ચૂકવણી કરીએ છીએ. cmdlets ની અંદર કોઈ જાદુ નથી: સમાન સ્ક્રિપ્ટ, પરંતુ નીચલા સ્તરે, સની ભારતના માસ્ટરના કુશળ હાથ દ્વારા લખાયેલ.

હવે, Get-View સાથે સરખામણી કરવા માટે, ચાલો Get-VM cmdlet લઈએ: તે વર્ચ્યુઅલ મશીનને ઍક્સેસ કરે છે અને એક સંયુક્ત ઑબ્જેક્ટ પરત કરે છે, એટલે કે, તે અન્ય સંબંધિત ઑબ્જેક્ટને તેની સાથે જોડે છે: VMHost, Datastore, વગેરે.  

તેના સ્થાને ગેટ-વ્યૂ પરત કરેલા ઑબ્જેક્ટમાં બિનજરૂરી કંઈપણ ઉમેરતું નથી. તદુપરાંત, તે અમને કઈ માહિતીની જરૂર છે તે સખત રીતે સ્પષ્ટ કરવાની મંજૂરી આપે છે, જે આઉટપુટ ઑબ્જેક્ટને સરળ બનાવશે. સામાન્ય રીતે વિન્ડોઝ સર્વરમાં અને ખાસ કરીને હાયપર-વીમાં, Get-WMIObject cmdlet એ ડાયરેક્ટ એનાલોગ છે - વિચાર બરાબર એ જ છે.

ગેટ-વ્યૂ પોઈન્ટ ઑબ્જેક્ટ્સ પર નિયમિત કામગીરી માટે અસુવિધાજનક છે. પરંતુ જ્યારે હજારો અને હજારો વસ્તુઓની વાત આવે છે, ત્યારે તેની કોઈ કિંમત નથી.

તમે VMware બ્લોગ પર વધુ વાંચી શકો છો: ગેટ-વ્યૂનો પરિચય

હવે હું તમને વાસ્તવિક કેસનો ઉપયોગ કરીને બધું બતાવીશ. 

VM અનલોડ કરવા માટે સ્ક્રિપ્ટ લખી રહ્યા છીએ

એક દિવસ મારા સાથીદારે મને તેની સ્ક્રિપ્ટ ઓપ્ટિમાઇઝ કરવા કહ્યું. કાર્ય એક સામાન્ય દિનચર્યા છે: ડુપ્લિકેટ cloud.uuid પેરામીટર સાથે તમામ VM શોધો (હા, vCloud ડિરેક્ટરમાં VM ક્લોન કરતી વખતે આ શક્ય છે). 

સ્પષ્ટ ઉકેલ જે મનમાં આવે છે તે છે:

1. તમામ VM ની યાદી મેળવો.
2. સૂચિને કોઈક રીતે પાર્સ કરો.

મૂળ આવૃત્તિ આ સરળ સ્ક્રિપ્ટ હતી:

function Get-CloudUUID1 {
   # Получаем список всех ВМ
   $vms = Get-VM
   $report = @()

   # Обрабатываем каждый объект, получая из него только 2 свойства: Имя ВМ и Cloud UUID.
   # Заносим данные в новый PS-объект с полями VM и UUID
   foreach ($vm in $vms)
   {
       $table = "" | select VM,UUID

       $table.VM = $vm.name
       $table.UUID = ($vm | Get-AdvancedSetting -Name cloud.uuid).Value
          
       $report += $table
   }
# Возвращаем все объекты
   $report
}
# Далее РУКАМИ парсим полученный результат

બધું અત્યંત સરળ અને સ્પષ્ટ છે. તે કોફી બ્રેક સાથે થોડી મિનિટોમાં લખી શકાય છે. ફિલ્ટરેશન પર સ્ક્રૂ કરો અને તે થઈ ગયું.

પરંતુ ચાલો સમય માપીએ:

2 મિનિટ 47 સેકન્ડ લગભગ 10k VMs પર પ્રક્રિયા કરતી વખતે. બોનસ એ ફિલ્ટર્સની ગેરહાજરી અને પરિણામોને મેન્યુઅલી સૉર્ટ કરવાની જરૂરિયાત છે. દેખીતી રીતે, સ્ક્રિપ્ટને ઑપ્ટિમાઇઝેશનની જરૂર છે.

જ્યારે તમારે vCenter પાસેથી એકસાથે હોસ્ટ મેટ્રિક્સ મેળવવાની જરૂર હોય અથવા હજારો ઑબ્જેક્ટ પર પ્રક્રિયા કરવાની જરૂર હોય ત્યારે રનસ્પેસ એ બચાવમાં સૌ પ્રથમ આવે છે. ચાલો જોઈએ કે આ અભિગમ શું લાવે છે.

પ્રથમ ગતિ ચાલુ કરો: પાવરશેલ રનસ્પેસ

આ સ્ક્રિપ્ટ માટે પ્રથમ વસ્તુ જે ધ્યાનમાં આવે છે તે છે લૂપને ક્રમિક રીતે નહીં, પરંતુ સમાંતર થ્રેડોમાં, તમામ ડેટાને એક ઑબ્જેક્ટમાં એકત્રિત કરો અને તેને ફિલ્ટર કરો. 

પરંતુ એક સમસ્યા છે: PowerCLI અમને vCenter પર ઘણા સ્વતંત્ર સત્રો ખોલવાની મંજૂરી આપશે નહીં અને એક રમુજી ભૂલ ફેંકશે:

You have modified the global:DefaultVIServer and global:DefaultVIServers system variables. This is not allowed. Please reset them to $null and reconnect to the vSphere server.

આને ઉકેલવા માટે, તમારે પહેલા સ્ટ્રીમમાં સત્રની માહિતી પાસ કરવી પડશે. ચાલો યાદ રાખીએ કે પાવરશેલ એવા ઑબ્જેક્ટ્સ સાથે કામ કરે છે જે ફંક્શન અથવા સ્ક્રિપ્ટબ્લોકમાં પેરામીટર તરીકે પસાર કરી શકાય છે. ચાલો $global:DefaultVIServers (-NotDefault કી સાથે કનેક્ટ-VIServer) ને બાયપાસ કરીને, આવા ઑબ્જેક્ટના સ્વરૂપમાં સત્ર પસાર કરીએ:

$ConnectionString = @()
foreach ($vCenter in $vCenters)
   {
       try {
           $ConnectionString += Connect-VIServer -Server $vCenter -Credential $Credential -NotDefault -AllLinked -Force -ErrorAction stop -WarningAction SilentlyContinue -ErrorVariable er
       }
       catch {
           if ($er.Message -like "*not part of a linked mode*")
           {
               try {
                   $ConnectionString += Connect-VIServer -Server $vCenter -Credential $Credential -NotDefault -Force -ErrorAction stop -WarningAction SilentlyContinue -ErrorVariable er
               }
               catch {
                   throw $_
               }
              
           }
           else {
               throw $_
           }
       }
   }

હવે ચાલો Runspace Pools દ્વારા મલ્ટિથ્રેડિંગનો અમલ કરીએ.  

અલ્ગોરિધમ નીચે મુજબ છે:

1. અમને તમામ VM ની યાદી મળે છે.
2. સમાંતર સ્ટ્રીમ્સમાં આપણને cloud.uuid મળે છે.
3. અમે એક ઑબ્જેક્ટમાં સ્ટ્રીમ્સમાંથી ડેટા એકત્રિત કરીએ છીએ.
4. અમે ઑબ્જેક્ટને CloudUUID ફીલ્ડના મૂલ્ય દ્વારા જૂથબદ્ધ કરીને ફિલ્ટર કરીએ છીએ: જ્યાં અનન્ય મૂલ્યોની સંખ્યા 1 કરતા વધારે હોય તે VM છે જે અમે શોધી રહ્યા છીએ.

પરિણામે, અમને સ્ક્રિપ્ટ મળે છે:

function Get-VMCloudUUID {
   param (
       [string[]]
       [ValidateNotNullOrEmpty()]
       $vCenters = @(),
       [int]$MaxThreads,
       [System.Management.Automation.PSCredential]
       [System.Management.Automation.Credential()]
       $Credential
   )

   $ConnectionString = @()

   # Создаем объект с сессионным ключом
   foreach ($vCenter in $vCenters)
   {
       try {
           $ConnectionString += Connect-VIServer -Server $vCenter -Credential $Credential -NotDefault -AllLinked -Force -ErrorAction stop -WarningAction SilentlyContinue -ErrorVariable er
       }
       catch {
           if ($er.Message -like "*not part of a linked mode*")
           {
               try {
                   $ConnectionString += Connect-VIServer -Server $vCenter -Credential $Credential -NotDefault -Force -ErrorAction stop -WarningAction SilentlyContinue -ErrorVariable er
               }
               catch {
                   throw $_
               }
              
           }
           else {
               throw $_
           }
       }
   }

   # Получаем список всех ВМ
   $Global:AllVMs = Get-VM -Server $ConnectionString

   # Поехали!
   $ISS = [system.management.automation.runspaces.initialsessionstate]::CreateDefault()
   $RunspacePool = [runspacefactory]::CreateRunspacePool(1, $MaxThreads, $ISS, $Host)
   $RunspacePool.ApartmentState = "MTA"
   $RunspacePool.Open()
   $Jobs = @()

# ScriptBlock с магией!)))
# Именно он будет выполняться в потоке
   $scriptblock = {
       Param (
       $ConnectionString,
       $VM
       )

       $Data = $VM | Get-AdvancedSetting -Name Cloud.uuid -Server $ConnectionString | Select-Object @{N="VMName";E={$_.Entity.Name}},@{N="CloudUUID";E={$_.Value}},@{N="PowerState";E={$_.Entity.PowerState}}

       return $Data
   }
# Генерируем потоки

   foreach($VM in $AllVMs)
   {
       $PowershellThread = [PowerShell]::Create()
# Добавляем скрипт
       $null = $PowershellThread.AddScript($scriptblock)
# И объекты, которые передадим в качестве параметров скрипту
       $null = $PowershellThread.AddArgument($ConnectionString)
       $null = $PowershellThread.AddArgument($VM)
       $PowershellThread.RunspacePool = $RunspacePool
       $Handle = $PowershellThread.BeginInvoke()
       $Job = "" | Select-Object Handle, Thread, object
       $Job.Handle = $Handle
       $Job.Thread = $PowershellThread
       $Job.Object = $VM.ToString()
       $Jobs += $Job
   }

# Ставим градусник, чтобы наглядно отслеживать выполнение заданий
# И здесь же прибиваем отработавшие задания
   While (@($Jobs | Where-Object {$_.Handle -ne $Null}).count -gt 0)
   {
       $Remaining = "$($($Jobs | Where-Object {$_.Handle.IsCompleted -eq $False}).object)"

       If ($Remaining.Length -gt 60) {
           $Remaining = $Remaining.Substring(0,60) + "..."
       }

       Write-Progress -Activity "Waiting for Jobs - $($MaxThreads - $($RunspacePool.GetAvailableRunspaces())) of $MaxThreads threads running" -PercentComplete (($Jobs.count - $($($Jobs | Where-Object {$_.Handle.IsCompleted -eq $False}).count)) / $Jobs.Count * 100) -Status "$(@($($Jobs | Where-Object {$_.Handle.IsCompleted -eq $False})).count) remaining - $remaining"

       ForEach ($Job in $($Jobs | Where-Object {$_.Handle.IsCompleted -eq $True})){
           $Job.Thread.EndInvoke($Job.Handle)     
           $Job.Thread.Dispose()
           $Job.Thread = $Null
           $Job.Handle = $Null
       }
   }

   $RunspacePool.Close() | Out-Null
   $RunspacePool.Dispose() | Out-Null
}


function Get-CloudUUID2
{
   [CmdletBinding()]
   param(
   [string[]]
   [ValidateNotNullOrEmpty()]
   $vCenters = @(),
   [int]$MaxThreads = 50,
   [System.Management.Automation.PSCredential]
   [System.Management.Automation.Credential()]
   $Credential)

   if(!$Credential)
   {
       $Credential = Get-Credential -Message "Please enter vCenter credentials."
   }

   # Вызов функции Get-VMCloudUUID, где мы распараллеливаем операцию
   $AllCloudVMs = Get-VMCloudUUID -vCenters $vCenters -MaxThreads $MaxThreads -Credential $Credential
   $Result = $AllCloudVMs | Sort-Object Value | Group-Object -Property CloudUUID | Where-Object -FilterScript {$_.Count -gt 1} | Select-Object -ExpandProperty Group
   $Result
}

આ સ્ક્રિપ્ટની સુંદરતા એ છે કે તેનો ઉપયોગ ફક્ત સ્ક્રિપ્ટબ્લોક અને પરિમાણોને બદલીને અન્ય સમાન કેસોમાં થઈ શકે છે જે સ્ટ્રીમમાં પસાર કરવામાં આવશે. તેનો શોષણ કરો!

અમે સમય માપીએ છીએ:

55 સેકન્ડ. તે વધુ સારું છે, પરંતુ તે હજુ પણ ઝડપી હોઈ શકે છે. 

ચાલો બીજી ઝડપ પર જઈએ: GetView

ચાલો શોધી કાઢીએ કે શું ખોટું છે.
પ્રથમ અને અગ્રણી, Get-VM cmdlet એક્ઝેક્યુટ કરવામાં લાંબો સમય લે છે.
બીજું, Get-AdvancedOptions cmdlet પૂર્ણ થવામાં વધુ સમય લે છે.
ચાલો પહેલા બીજા સાથે વ્યવહાર કરીએ. 

Get-AdvancedOptions વ્યક્તિગત VM ઑબ્જેક્ટ્સ માટે અનુકૂળ છે, પરંતુ ઘણા ઑબ્જેક્ટ્સ સાથે કામ કરતી વખતે ખૂબ જ અણઘડ છે. આપણે વર્ચ્યુઅલ મશીન ઓબ્જેક્ટમાંથી જ માહિતી મેળવી શકીએ છીએ (ગેટ-વીએમ). તે એક્સ્ટેંશનડેટા ઑબ્જેક્ટમાં સારી રીતે દફનાવવામાં આવ્યું છે. ફિલ્ટરિંગથી સજ્જ, અમે જરૂરી ડેટા મેળવવાની પ્રક્રિયાને ઝડપી બનાવીએ છીએ.

હાથની થોડી હિલચાલ સાથે આ છે:

VM | Get-AdvancedSetting -Name Cloud.uuid -Server $ConnectionString | Select-Object @{N="VMName";E={$_.Entity.Name}},@{N="CloudUUID";E={$_.Value}},@{N="PowerState";E={$_.Entity.PowerState}}

આમાં ફેરવાય છે:

$VM | Where-Object {($_.ExtensionData.Config.ExtraConfig | Where-Object {$_.key -eq "cloud.uuid"}).Value -ne $null} | Select-Object @{N="VMName";E={$_.Name}},@{N="CloudUUID";E={($_.ExtensionData.Config.ExtraConfig | Where-Object {$_.key -eq "cloud.uuid"}).Value}},@{N="PowerState";E={$_.summary.runtime.powerstate}}

આઉટપુટ Get-AdvancedOptions જેવું જ છે, પરંતુ તે ઘણી વખત ઝડપી કામ કરે છે. 

હવે Get-VM માટે. તે ઝડપી નથી કારણ કે તે જટિલ વસ્તુઓ સાથે વ્યવહાર કરે છે. એક તાર્કિક પ્રશ્ન ઊભો થાય છે: જ્યારે આપણને ફક્ત VM ના નામ, તેની સ્થિતિ અને મુશ્કેલ વિશેષતાના મૂલ્યની જરૂર હોય ત્યારે આ કિસ્સામાં અમને વધારાની માહિતી અને એક ભયંકર PSO ઑબ્જેક્ટની શા માટે જરૂર છે?  

વધુમાં, Get-AdvancedOptions ના રૂપમાં અવરોધ સ્ક્રિપ્ટમાંથી દૂર કરવામાં આવ્યો છે. રનસ્પેસ પૂલ્સનો ઉપયોગ હવે ઓવરકિલ જેવું લાગે છે કારણ કે સત્ર સોંપતી વખતે સ્ક્વોટ થ્રેડોમાં ધીમા કાર્યને સમાંતર કરવાની જરૂર નથી. સાધન સારું છે, પરંતુ આ કેસ માટે નહીં. 

ચાલો એક્સ્ટેંશનડેટાના આઉટપુટને જોઈએ: તે ગેટ-વ્યૂ ઑબ્જેક્ટ સિવાય બીજું કંઈ નથી. 

ચાલો પાવરશેલ માસ્ટર્સની પ્રાચીન તકનીક પર કૉલ કરીએ: ફિલ્ટર્સ, સૉર્ટિંગ અને ગ્રૂપિંગનો ઉપયોગ કરીને એક લાઇન. અગાઉની બધી ભયાનકતા સુંદર રીતે એક લાઇનમાં તૂટી ગઈ છે અને એક સત્રમાં ચલાવવામાં આવી છે:

$AllVMs = Get-View -viewtype VirtualMachine -Property Name,Config.ExtraConfig,summary.runtime.powerstate | Where-Object {($_.Config.ExtraConfig | Where-Object {$_.key -eq "cloud.uuid"}).Value -ne $null} | Select-Object @{N="VMName";E={$_.Name}},@{N="CloudUUID";E={($_.Config.ExtraConfig | Where-Object {$_.key -eq "cloud.uuid"}).Value}},@{N="PowerState";E={$_.summary.runtime.powerstate}} | Sort-Object CloudUUID | Group-Object -Property CloudUUID | Where-Object -FilterScript {$_.Count -gt 1} | Select-Object -ExpandProperty Group

અમે સમય માપીએ છીએ:

9 સેકંડ ઇચ્છિત સ્થિતિ દ્વારા ફિલ્ટરિંગ સાથે લગભગ 10k ઑબ્જેક્ટ્સ માટે. સરસ!

તેના બદલે એક નિષ્કર્ષ

સ્વીકાર્ય પરિણામ સીધા સાધનની પસંદગી પર આધારિત છે. તે હાંસલ કરવા માટે બરાબર શું પસંદ કરવું જોઈએ તે ખાતરીપૂર્વક કહેવું ઘણીવાર મુશ્કેલ હોય છે. સ્ક્રિપ્ટને ઝડપી બનાવવા માટેની દરેક સૂચિબદ્ધ પદ્ધતિઓ તેની લાગુ પડવાની મર્યાદામાં સારી છે. હું આશા રાખું છું કે આ લેખ તમને તમારા ઇન્ફ્રાસ્ટ્રક્ચરમાં પ્રક્રિયા ઓટોમેશન અને ઑપ્ટિમાઇઝેશનની મૂળભૂત બાબતોને સમજવાના મુશ્કેલ કાર્યમાં મદદ કરશે.

પીએસ: લેખ તૈયાર કરવામાં મદદ અને સમર્થન માટે લેખક સમુદાયના તમામ સભ્યોનો આભાર માને છે. પંજાવાળા પણ. અને તે પણ જેમને પગ નથી, જેમ કે બોઆ કન્સ્ટ્રક્ટર.

સોર્સ: www.habr.com