Szalay Márton

Szalay Márton
PowerShell-példatár
2008
Szalay Márton: PowerShell-példatár
A Microsoft, Active Directory, PowerShell, Windows, .NET, Windows Server 2003,

Windows Server 2008, Windows XP, Windows Vista, Microsoft Exchange Server, Vi-
sual Studio, Visual Basic.NET, Visual C#.NET, SQL Server nevek a Microsoft Corpora-
tion (Redmond, USA) bejegyzett védjegyei. Minden egyéb, a könyvben előforduló
márka- és terméknév a megfelelő jogtulajdonos védjegye.
© Szalay Márton, 2008.
Felelős szerkesztő: Kis Balázs
ISBN 978-963-...
A könyv szövegének helyességét és az elválasztásokat a MorphoLo-

gic Helyesek 2007 programjával ellenőriztük.
Minden jog fenntartva. Jelen könyvet, illetve annak részeit a kiadó előze-
tes írásbeli hozzájárulása nélkül tilos reprodukálni, adatrögzítő rendszer-
ben tárolni, bármilyen formában vagy eszközzel elektronikus úton vagy
más módon közölni.
SZAK Kiadó Kft.  Az 1795-ben alapított Magyar Könyvkiadók

és Könyvterjesztők Egyesületének tagja  2060 Bicske, Diófa u. 3.
 Tel.: 36-22-350-209  Fax: 36-22-565-311  www.szak.hu 
e-mail: info@szak.hu  Kiadóvezető: Kis Ádám  Főszerkesztő:
Kis Balázs
Tartalom
Előszó ..................................................................................................................... 7
1. fejezet: Bevezetés ............................................................................................. 9
1.1. Új parancssor: a PowerShell ......................................................................... 9
1.2. Bevezetés az objektumorientált programozásba ...................................... 15
Osztályok és példányok ................................................................................. 17
Egységbezárás ................................................................................................. 18
Öröklődés ......................................................................................................... 18
Többalakúság ................................................................................................... 19
Osztályok, objektumok és metódusok ......................................................... 19
1.3. Ismerkedés a .NET keretrendszerrel ......................................................... 20
Mi a .NET? ....................................................................................................... 20
A .NET legfontosabb szolgáltatásai .............................................................. 21
A .NET-alapú programozás ........................................................................... 22
A .NET-objektumok ........................................................................................ 23
2. fejezet: Ismerkedés a PowerShellel ............................................................ 27
2.1. Telepítés ........................................................................................................ 27
2.2. Parancsok ...................................................................................................... 29
2.3. A legfontosabb parancselemek .................................................................. 31
2.4. Változók, gyűjtemények, operátorok ........................................................ 34
A változók ........................................................................................................ 34
Karakterláncok ................................................................................................ 36
Gyűjtemények ................................................................................................. 38
Műveletek, operátorok ................................................................................... 40
A reguláris kifejezések ................................................................................... 42
A feltételvizsgálat: az if operátor .................................................................. 44
2.5. A PowerShell mint számológép ................................................................. 45
2.6. Ciklusok ........................................................................................................ 48
2.7. Objektumok kezelése ................................................................................... 51
2.8. A kimenet formázása ................................................................................... 59
A Format parancselemek ............................................................................... 60
Az Out parancselemek ................................................................................... 61
Az Export parancselemek .............................................................................. 62
Formázás az -f operátorral ............................................................................. 63
Tartalomjegyzék
3. fejezet: A rendszerfelügyelet alapjai a PowerShellben ........................ 69

3.1. A függvények ............................................................................................... 69
3.2. Folyamatok kezelése .................................................................................... 72
3.3. Dátum és idő ................................................................................................. 76
3.4. Az eseménynapló ......................................................................................... 79
3.5. Szkriptek futtatása fájlból ........................................................................... 81
Futtatási házirend ........................................................................................... 82
Digitális aláírás ................................................................................................ 83
4. fejezet: Fájlkezelés ........................................................................................ 87
4.1. Fájlok és mappák .......................................................................................... 87
4.2. Fájlok tartalmának beolvasása ................................................................... 91
4.3. A fájlokhoz és mappákhoz tartozó engedélyek ....................................... 94
5. fejezet: A beállításjegyzék kezelése ......................................................... 97
5.1. A beállításjegyzék mint meghajtó .............................................................. 97
5.2. A kulcsok kezelése ....................................................................................... 99
5.3. Értékek módosítása ..................................................................................... 100
5.4. Engedélyek módosítása a beállításjegyzékben ........................................ 102
6. fejezet: Haladó rendszerfelügyelet a PowerShellel ............................... 105
6.1. A WMI kezelése .......................................................................................... 105
6.2. Az Active Directory kezelése ..................................................................... 108
6.3. SQL-adatbázisok kezelése .......................................................................... 115
6.4. A rendszer kezelése szkriptekkel .............................................................. 117
7. fejezet: Az Exchange Server 2007 és a PowerShell ................................. 125
7.1. A PowerShell beépülő moduljai ................................................................ 125
7.2. Postaládák létrehozása ............................................................................... 126
7.3. A postaládák méretének meghatározása ................................................. 128
7.4. Az Exchange-kiszolgáló megfigyelése ..................................................... 129
8. fejezet: A PowerShell bővítése ................................................................. 133
8.1. Külső eszközök ............................................................................................ 133
PowerShell Community Extensions ............................................................ 133
PowerGUI ....................................................................................................... 134
PowerShell Analyzer ..................................................................................... 135
8.2. ASP.NET-alkalmazás fejlesztése ............................................................... 136
A függelék: A példák jegyzéke ...................................................................... 141
B függelék: Szótár ............................................................................................. 169
C függelék: Felhasznált és ajánlott irodalom ............................................... 183
Tárgymutató ....................................................................................................... 185
6
Előszó
Elidegenedtünk a technikától. Nem tudjuk már, mi van az autó mo-

torházában; programozóként sem ismerjük sem a számítógépünk,
sem a saját programunk összes alkotóelemét. Az autó fedélzeti szá-
mítógépe, a számítógép grafikus kezelőfelülete elfedi előlünk a
rendszer valódi szerkezetét. Ez jó, mert a legtöbb műveletet gyor-
sabban és könnyebben végezhetjük el, mint grafikus felület nélkül –
és rossz, mert a gyorsabb és könnyebb munka kedvéért lemondtunk
a rendszer feletti teljes ellenőrzésről.
Mindez persze nem ok nélkül történt: a rendszereink, a számító-
gépeken futó programok sokkal bonyolultabbak lettek, miközben a
technikával szemben egyre nagyobbak a követelmények. Olyan fel-
adatokat kapunk, amelyeket nem tudnánk határidőre elvégezni, ha
meg kellene értenünk az alkotóelemek működését, és az alapoktól
kellene építkeznünk. Sokunkból biztosan hiányzik a kíváncsiság is,
nem vagyunk olyanok, mint Zebike a Sárkányos mese igazából1 című
könyvben, aki a repülő kastélyban elsősorban a gépházat keresi. A
legtöbbünknek azonban leginkább ideje nincs kíváncsinak lenni, és
ez különösen igaz a rendszergazdákra.
A PowerShell képében a Microsoft a rendszergazdák kezébe
adott valóban nagyon erős eszközt, amely úgy ad több ellenőrzést a
rendszer fölött, hogy közben a feladat elvégzése nem jár több mun-
kával. A PowerShell könnyen megtanulható parancssor, amely ugyan-
akkor teljesen programozható, és a legtöbb rendszerobjektumhoz
hozzá lehet férni belőle.
1 Kamarás István: Sárkányos mese igazából. Móra, Budapest, 1979.

Előszó
Szalay Márton gyakorló rendszergazdaként olyan könyvet írt a

PowerShellről, amely úgy alkalmazkodik a rendszergazdák igényei-
hez, mint maga a PowerShell. Az Olvasó olyan PowerShell-gyors-
talpalót tart a kezében, amelyből – meglevő ismereteit is felhasználva
– nagyon gyorsan, akár munka közben is megtanulhatja a munkájá-
hoz szükséges parancsprogramozást (vagyis szkriptezést).
A könyv leírja a PowerShell használatához szükséges programo-
zási alapismereteket, foglalkozik a fájlok, a mappák, a folyamatok és
a beállításjegyzék kezelésével. Szó esik az Active Directory és az
Exchange Server felügyeletéről, az SQL-adatbázisok használatáról és
a PowerShell bővítéséről is.
Könyvünk címe „példatár”, bár egyáltalán nem olyan, mint a ma-
tematikaérettségiről ismert „zöld könyv”. A példák a magyarázatok
részei, azonban önállóan is felhasználhatók.
A könyv 133 példát tartalmaz; ezeket kulcsszavak szerint rendez-
ve felsoroltuk a könyv végén található Példajegyzékben is.
Egy 192 oldalas könyv nem tartalmazhat minden tudnivalót a
PowerShellről. Ez egyrészt azt jelenti, hogy az Olvasó jó hasznát ve-
szi korábbi ismereteinek – a programozásról, a .NET-ről, a Windows-
hálózatokról, az Active Directory-címtárról és még sok minden más-
ról. Másfelől pedig sok mindent lehet még olvasni a PowerShellről és
a könyvben érintett többi témáról is. Ezt igyekszik megkönnyíteni a
könyv végén levő irodalomjegyzék és a könyvhöz tartozó, folyama-
tosan bővülő weblap is, amely a http://www.powershellkonyv.hu cí-
men érhető el.
Budapest, 2008. augusztus 17.
Kis Balázs
felelős szerkesztő
8
ELSŐ FEJEZET
Bevezetés
1.1. Új parancssor: a PowerShell
Még egy parancssor?
„Na, még egy parancssor. Még valami, amivel a Microsoft megnehe-

zíti a rendszergazdák amúgy sem egyszerű életét.” – hallani ezt sok
üzemeltetőtől. A könyv célja az, hogy eloszlassa ezt a tévhitet és
megmutassa, hogy a PowerShell használatával a rendszerfelügyeleti
feladatok jelentősen egyszerűsíthetők.
A Microsoft 2006 novemberének végén, az Exchange Server 2007
bejelentésével egy időben, ingyenesen letölthetővé tette új parancs-
sorát, a PowerShellt. Az Exchange 2007 az első termék, mely a
PowerShellre épül, és úgy tűnik, hogy a jövőben egyre több kiszolgá-
ló-alkalmazás követi ezt a példát Ez azt jelenti, hogy e programok
valamennyi szolgáltatását teljességükben csak a PowerShellből ér-
hetjük el. Ha tehát más nem is, ez motiválhat minket, hogy közelebb-
ről megismerjük az új parancssort. Emellett, mint minden más pa-
rancssornak, ennek is az a fő rendeltetése, hogy a rendszerfelügyelet-
tel kapcsolatos teendőinket automatizálhassuk.
A rendszerhéj
A rendszerhéjak használata létfontosságú az operációs rendszerekkel

való kommunikációban, mert ezek segítségével végezhetünk el olyan
alapvető feladatokat, mint a fájlok kezelése, parancsok futtatása vagy
az alkalmazások elindítása. Mindenkinek, aki használt már számító-

gépet, kapcsolatba kellett kerülnie a rendszerhéjakkal, akár úgy,
hogy parancsokat gépelt be, akár úgy, hogy ikonokra kattintott. A
számítógéppel végzett mindennapi munka során elengedhetetlen,
hogy egy vagy több rendszerhéjjal „beszélgessünk”.
Kétféle rendszerhéj van: a g r a f i k u s f e l ü l e t ű (ilyen például
a Windowsokban található Windows-intéző) és a szöveges, p a -
r a n c s s o r i f e l ü l e t ű (CLI, Command Line Interface). Ez utóbbi faj-
tába tartozik többek között a Unixok és Linuxok alatt használt bash, a
windowsos Parancssor (Command Prompt), illetve a PowerShell1 is.
Mindkét típusnak vannak előnyei és hátrányai. A grafikus felüle-
tek sokkal könnyebben kezelhetők, intuitívabbak: egyszerűen csak a
megfelelő ikonra kell kattintani, vagy egy parancsgombot meg-
nyomni, és jól eséllyel az történik, amit elvárunk. Hátrányuk viszont,
hogy nehezebben programozhatók és automatizálhatók.
A szöveges felületű rendszerhéjakra egyszerűen írhatunk több
parancsból álló fájlokat, s z k r i p t e k e t (az angol script szó forga-
tókönyvet jelent), melyek automatikusan elvégzik a gyakran vagy
sokszor ismétlődő műveleteket, viszont használatukhoz előbb tanu-
lásra és jellemzően mélyebb ismeretekre van szükség.
Bizonyos feladatokhoz az egyik, másokhoz a másik felület a hasz-
nálhatóbb. Mindig célszerű megfelelően megválasztani az eszközt.
Ha létre szeretnénk hozni egy felhasználót az Active Directory cím-
tárban, egyszerűbb és gyorsabb, ha az Active Directory – felhasználók
és számítógépek (Active Directory Users and Computers) nevű felügye-
leti (MMC) konzolban tesszük ezt meg, mert így nem kell utánanézni
annak, hogy ezt parancssorból milyen módon tehetjük meg. De más
a helyzet, ha mondjuk, 500 felhasználói fiókot kell nagyon hamar ki-
alakítanunk. Ilyenkor gyorsabb, ha valamiféle szkriptet írunk rá.
1 power: erő, hatalom; az angol nyelvben előtagként szokás a nagy teljesít-

mény vagy a nagy hatékonyság szinonimájaként is használni; shell: rend-
szerhéj
10
1. fejezet: Bevezetés
Olyan, mint régen
A PowerShellel való ismerkedésünket kezdjük rögtön úgy, hogy el-

indítjuk a Start menü Windows PowerShell 1.0 mappájából, majd be-
gépeljük a már jól ismert parancssori parancsokat:
PS C:\Users\MartonSz> cd \
PS C:\> dir
Directory: Microsoft.PowerShell.Core\FileSystem::C:\
Mode LastWriteTime Length Name

---- ------------- ------ ----
d-r-- 2007.11.06. 12:19 Program Files
d-r-- 2007.11.05. 16:55 Users
d---- 2007.11.05. 17:38 Windows
-a--- 2006.09.18. 23:43 24 autoexec.bat
-ar-s 2007.09.14. 21:43 8192 BOOTSECT.BAK
-a--- 2006.09.18. 23:43 10 config.sys
PS C:\> md PS-konyv

---- ------------- ------ ----
d---- 2007.11.14. 12:37 PS-konyv
PS C:\> dir

---- ------------- ------ ----
d-r-- 2007.11.06. 12:19 Program Files
d---- 2007.11.14. 12:37 PS-konyv
d-r-- 2007.11.05. 16:55 Users
d---- 2007.11.05. 17:38 Windows
-a--- 2006.09.18. 23:43 24 autoexec.bat
-ar-s 2007.09.14. 21:43 8192 BOOTSECT.BAK
-a--- 2006.09.18. 23:43 10 config.sys
PS C:\>
11
Nagy meglepetés nem ér minket, az történik, amit vártunk: először

átlépünk az aktuális meghajtó gyökérkönyvtárába, majd kilistázzuk
annak tartalmát, és létrehozunk egy új mappát; bár a kimenet formá-
tuma valamelyest különbözik a hagyományostól. Látunk furcsa,
számunkra egyelőre értelmetlen kifejezéseket; ezeket később – ahogy
egyre többet használjuk a PowerShellt – megtanuljuk.
A PowerShellt fejlesztői igyekeztek a Windows hagyományos pa-
rancssorához minél hasonlóbbá tenni, hogy könnyebb legyen meg-
szokni és megtanulni. Próbálkozhatunk más feladatokkal is, minden
alapvető funkció (rd, copy, del, ren stb.) hasonlóképp működik. Akár
más programokat is futtathatunk belőle (mmc.exe, cmd.exe stb.).
Mivel tud többet a PowerShell más

parancssoroknál?
Az eddigi példákból úgy tűnik, hogy a PowerShell ugyanúgy műkö-

dik, mint a Windows-parancssor. A későbbiekben láthatjuk, hogy ez
csak a felszínen van így, valójában semmi köze nincs a „hagyomá-
nyos”parancssorhoz: teljesen más logikára épül.
Valamennyi manapság használt parancssor tudja kezelni az úgy-
nevezett c s ö v e z é s t (piping). Ez a következőt jelenti: amit az egyik
parancs a képernyőre írna, a képernyő helyett egy másik program
bemenetére irányítjuk. A második program az első által kiírt adato-
kat dolgozza fel bemenetként, majd e feldolgozás eredményét jeleníti
meg a képernyőn. Így olyan összetettebb feladatokat is megoldha-
tunk, amelyeket nem tudnánk, ha az adott eszközöket külön kellene
alkalmaznunk. Ezt a műveletet azért nevezik csövezésnek, mert a
különböző programokat a pipe (|) karakterrel kapcsoljuk össze, az
angol pipe szó pedig csövet jelent.
Bár ezt a funkciót – korlátozásokkal – használhattuk a korábbi
Windows-parancssorban is, a Linux-világban sokkal általánosabban
12
alkalmazzák. Ha a bash parancshéjat használjuk, és begépeljük az ls

parancsot, megkapjuk az aktuális könyvtár tartalmát:
[martonsz@extra ~/ps]$ ls
dump.txt FILES index.html installer.sh vid1resp.txt
Ha ebből csak azokra a fájlokra vagyunk kíváncsiak, amelyek nevé-

ben szerepel a .txt kiterjesztés, az ls parancs kimenetét bele kell csö-
veznünk a grep parancsba, melynek argumentumként megadjuk a
.txt karaktersorozatot: 2
[martonsz@extra ~/ps]$ ls | grep .txt

dump.txt
vid1resp.txt
Viszont nem mindegy, hogy mi áll a kifejezés bal oldalán. Ha az ls

parancsnak megadjuk a -l kapcsolót is, teljesen más lesz az ered-
mény:
[martonsz@extra ~/ps]$ ls -l | grep .txt

-rw-r--r-- 1 root root 1630195 2006-10-19 11:04 dump.txt
-rw-r--r-- 1 root root 1286 2007-07-30 00:33 vid1resp.txt
A fenti példákban az történt, hogy az ls parancs megkérdezte az ope-

rációs rendszert, hogy az aktuális könyvtárban milyen fájlok találha-
tók, majd ezt a listát – a kiegészítő adatokkal együtt – egy karakter-
láncban visszaadta. Ezt a karakterláncot a grep program soronként
feldolgozta, majd ezek közül kiírta azokat, amelyekre illeszkedett a
megadott minta („.txt”); a többit „lenyelte”. Ez nagyon jól működik
egészen addig, amíg az így csövezett adatokkal nem próbálunk meg
valami egyéb műveletet végrehajtani, például összeszámolni a .txt
kiterjesztésű fájlok méretét, vagy kiszámolni, hogy két fájl létrehozá-
sának dátuma között mennyi idő telt el. Erre már kisebbfajta prog-
2 Mindezt persze megtehettük volna az ls *.txt paranccsal is: ezt a megol-

dást a példa kedvéért használtuk.
13
ramot kell írnunk, amely először kikeresi a karakterláncból, hogy

mely karakterek jelzik az adott fájl méretét vagy létrehozásának dá-
tumát és idejét. Ezután az adatokat olyan „emészthető” formára
hozza, amellyel már lehet matematikai műveleteket végezni.
Mennyivel egyszerűbb lenne a dolgunk, ha karakterlánc helyett
adatszerkezetet kapnánk eredményül: közvetlenül, az operációs
rendszer által is használt tulajdonságokat, méghozzá a megfelelő
formátumban; a fájl méretét például egész számként (integer).
A PowerShell egyszerűbb,
mint a Visual Basic-szkriptek
Írhatunk Visual Basic-szkriptet is, hogy elkérje a Windowstól a

könyvtárlistát, és abból kiválogassa azokat a fájlokat, melyek neve a
.txt karaktersorozatra végződik, majd összeadja ezek méretét:
On Error Resume Next

Dim ext, fso, size
ext = ".txt"
Set fso = CreateObject("Scripting.FileSystemObject")

size = 0
For each folderIdx In fso.GetFolder(".").files
If Right(folderIdx.Name,4)=ext Then size = size + _
fso.GetFile(folderIdx.Name).Size
Next
Wscript.StdOut.WriteLine("A " & ext & " fájlok mérete " & _
size & " bájt.")
Ennek az a hátránya, hogy alapos Visual Basic-ismereteket igényel,

továbbá nem árt, ha az embernek van fejlesztői tapasztalata is – és ne
feledkezzünk meg a temérdek szabadidőről sem. A feladat megoldá-
sához 13 sor kódot kellett írni! Képzeljük el, mekkora lenne egy
olyan szkript, amely végigjárja az adott kötet összes almappáját, ki-
14
gyűjti belőlük azokat a fájlokat, melyek két hétnél régebbiek, és áthe-

lyezi őket egy archiv nevű mappába – jobb nem is gondolni rá. Lát-
ható, hogy Visual Basicben rengeteg feladat elvégezhető, de bonyo-
lultsága miatt nem a rendszergazdák legkedvesebb eszköze.
A PowerShell ötvözi a parancssorok és a Visual Basic-szkriptek
előnyeit, sőt, annál sokkal többet is tud. Csövezéssel összeköthetjük
az egyes parancsokat, de közben mégsem szöveggel, hanem objek-
tumokkal dolgozunk; a dátum például dátum marad, nyugodtan
hozzáadhatunk egy évet vagy kivonhatunk belőle három hónapot:
az eredmény egy másik dátum lesz.
Nem túlzás azt állítani, hogy a PowerShell objektumorientált pa-
rancssor – ezért tisztában kell lennünk az objektumorientált progra-
mozás alapjaival, hogy hatékonyan kihasználhassuk.
A következőkben röviden ismertetjük az objektumorientált prog-
ramozás alapfogalmait; ez azonban kevés lesz ahhoz, hogy az Olvasó
részletesen is elmélyedhessen benne. Ezért az objektumorientált
programozásról számos könyvet felsoroltunk e könyv irodalomjegy-
zékében.
1.2. Bevezetés az objektumorientált

programozásba
A számítástechnika hőskorában a programok néhány száz sornyi, vi-
szonylag alacsony szintű utasításból álltak. Ezek könnyen áttekinthe-
tők és egy ember számára is jól kezelhetők voltak.
A magas szintű, strukturált programnyelvek megjelenése hatéko-
nyabb eszközzel látta el a fejlesztőket. Ezekben a megoldandó felada-
tot át kell alakítani a számítógép által értelmezhető adatokra és az
azt feldolgozó algoritmusra. Ennek megvalósítására számos prog-
ramnyelv készült, és ahogy nőtt a számítógéppel megoldott felada-
15
1.2. Bevezetés az objektumorientált programozásba
tok száma, úgy váltak a programozási nyelvek – és a programok – is

egyre bonyolultabbakká.
Amikor az 1980-as évekre a programok mérete és összetettsége
megnőtt, egyre inkább kezdtek előjönni a strukturált programterve-
zés korlátai. Ez idő tájt gyakori volt a határidők csúszása és az ered-
ménytelen fejlesztés. A problémákat igyekeztek valamilyen szabvá-
nyosítás, új módszertan vagy újrahasznosítható programkód segít-
ségével megoldani.
Az 60-as és a 80-as évek között a strukturált programozási mód-
szerek mellett fokozatosan megjelent egy újfajta elgondolás, az o b -
jektumorientált programozás.
Az objektumorientált programozás alapja az objektumszemlélet.
Ennek az a lényege, hogy a programozást az ember számára termé-
szetes úton közelítjük meg. Számunkra a világ objektumokból áll:
asztalok, székek, számítógépek, telefonok, focimeccsek, bankszámlák
stb. Szintén emberi tulajdonság, hogy megpróbáljuk ezeket az objek-
tumokat osztályozni, valamiféle sorba rendezni, bizonyos tulajdon-
ságaikat kiemelve, másokat háttérbe szorítva. Például a kutya és a
macska emlősök, a mosógép és a tűzhely háztartási gép, az úszás és
a tenisz sport, az Opel és a Renault autók, a busz és az autó járművek.
A különböző objektumokat számtalan módon osztályozhatjuk. Ez
attól függ, hogy miképpen viszonyulunk az adott objektumhoz,
mennyire ismerjük, milyen szolgáltatásait használjuk. Másképp osz-
tályozza az emberi agyat egy pszichiáter, és megint másképp egy
agysebész vagy a kannibál törzs egy tagja: mindegyikük számára
más a fontos.
Az objektumorientált programozás először is abból áll, hogy az
egyes objektumokból hierarchiát építünk. Ezt bizonyos fokig bár-
mely programnyelvben megtehetjük, mint ahogy elméletileg öngyúj-
tóval is felforralhatunk egy kád vizet – de sokkal egyszerűbb objek-
tumorientáltan programozni egy olyan nyelven, amelyet kifejezetten
erre terveztek. Az objektumorientált programozási nyelveknek, pél-
16
dául a C++-nak vagy a C#-nak, három szolgáltatásuk van, amely

fontos az emberek számára is természetes objektumazonosításban és
-osztályozásban: az e g y s é g b e z á r á s (encapsulation), az ö r ö k -
l ő d é s (inheritance) és a t ö b b a l a k ú s á g (polymorphism).
Osztályok és példányok
Mint említettük, az emberi gondolkodásban nagyon fontos a külön-

böző dolgok osztályozása, kategóriákba sorolása. Enélkül nem tud-
nánk a dolgokat elnevezni, és valószínűleg a beszéd és a gondolko-
dás is lehetetlen volna.
Csak Magyarországon több millió autó van: ezek közül egy a sa-
ját autónk (ha van). A magyar nyelvben ezt így fejezzük ki: ha azt
mondjuk: az autó, akkor a sajátunkra gondolunk vagy éppen arra,
amellyel megérkeztünk. Ha viszont csak azt mondjuk: autó, akkor az
összesről beszélünk – pontosabban egyikről sem, hanem arról az el-
vont kategóriáról, amelybe – közös tulajdonságai alapján – az összes
autó besorolható.
A fentieket az objektumorientált programozásban úgy fogalmaz-
zuk meg, hogy az autó mint elvont kategória az o s z t á l y (class), a
saját autónk pedig az osztály egyik p é l d á n y a (instance). Az osz-
tály azt határozza meg hogy az autó típusú objektumok milyen tulaj-
donságokkal rendelkezhetnek, a példány pedig azt, hogy a konkrét au-
tó a lehetségesek közül konkrétan mely tulajdonságokkal rendelkezik.
Autóvásárláskor fontos szempont az autó színe vagy az, hogy
mennyit fogyaszt. Az objektumszemlélet szerint ez azt jelenti, hogy
az autó osztály meghatározza, hogy az autónak van színe és fogyasz-
tása. Amikor már nézegetünk egy konkrét járművet, akkor az autó
osztály egy példányával foglalkozunk, amelyről tudjuk, hogy a színe
kék és a fogyasztása 5,5 l száz kilométerenként.
17
1.2. Bevezetés az objektumorientált programozásba
Az autó osztályból tehát úgy lesz az autó példánya, hogy az osz-

tály által meghatározott elvont tulajdonságokat (szín; fogyasztás) ki-
töltöttük konkrét értékekkel (kék; 5,5 l). Az objektumorientált prog-
ramozásban azt a műveletet, amelynek során konkrét értéket adunk
az osztályban megadott elvont tulajdonságoknak, és így létrehozzuk
az objektum példányát, p é l d á n y o s í t á s n a k (instantiation) ne-
vezzük. Mondhatjuk azt is, hogy az osztály az objektum t í p u s a .
Egységbezárás
A szoftverfejlesztés egyik legnagyobb problémája, hogy a fejlesztett

rendszerek egyre nagyobbak és bonyolultabbak. Az egységbezárás
lehetőséget nyújt arra, hogy a programot kisebb, önálló összetevőkre
bontsuk. Például egy banki rendszer fejlesztésekor valószínűleg
szükség lesz egy, a számlákat kifejező objektumra. Miután megter-
veztük a Számla osztályt, a továbbiakban nem kell foglalkoznunk en-
nek a megvalósításával. Ugyanúgy alkalmazhatjuk ezt is, mint az
egész számok tárolására használt integer típust. Az osztálynak kö-
szönhetően a programozónak elég a Számla típusú objektumok azon
tulajdonságaival foglalkoznia, amelyek az adott esetben fontosak, és
nem kell törődnie az objektum megvalósításával. Például fontos le-
het a számlatulajdonos neve és a számla egyenlege, de lényegtelen,
hogy a név 80 elemű karaktertömbben vagy karakterláncban van-e
tárolva.
Öröklődés
Az embereknek szokásuk, hogy az objektumokat hierarchiába ren-

dezik. Ez programozási szempontból is hasznos, és minden objek-
tumorientált nyelv támogatja az öröklődés révén. Az öröklődésnek
két nagyon fontos előnye van: az objektumokat hierarchiába szer-
18
vezhetjük, illetve a hierarchiában lejjebb található objektumok örö-

kölhetnek tulajdonságokat a feljebb lévő objektumoktól (a s z ü l ő -
o b j e k t u m o k t ó l ). Vegyünk két osztályt, a FolyóSzámla és a
HitelSzámla osztályt. Mindkettő a Számla osztályból ered. A Számla
osztály általánosabb, mint a FolyóSzámla vagy a HitelSzámla. Az
öröklődésnek köszönhetően megtalálhatók bennük a Számla osztály
jellemzői: a számlatulajdonos neve és a számla egyenlege.
Az új osztályok örökölhetik a meglévők tulajdonságait, de akár
módosíthatják is őket. A hitelszámláról például többet is költhetünk
a hitelkeretünknél (a számla egyenlegénél), de ilyenkor hitelkamatot
számítanak fel, míg a folyószámla esetén egyikre sincs lehetőség.
Többalakúság
Az objektumorientált programozás harmadik jellemzője a többala-

kúság. Ez lényegében azt jelenti, hogy több különböző objektumnak
lehet olyan közös tulajdonsága, amelyet különbözőképp valósítanak
meg. Vegyünk különböző járműveket: mindet valahol be kell indíta-
ni, vagyis programozási szemszögből, mindnek van „indítás” funk-
ciója. Hogy ezt valójában milyen módon kell megvalósítani, az a
járműtől függ. Egy autónál egyszerűen el kell fordítani a gyújtáskap-
csolót, míg egy gőzmozdony esetében ez sokkal bonyolultabb.
Osztályok, objektumok és metódusok
Az objektumok az adott dolgot leíró adatokból ( t u l a j d o n s á -

g o k b ó l ) , és az azon végezhető műveletekből ( m e t ó d u s o k -
b ó l ) állnak. Amikor viszont objektumorientált programot írnunk,
osztályokat kell meghatároznunk, nem objektumokat.
Az osztály a felhasználó vagy a rendszer által meghatározott tí-
pus, amely tulajdonságokból és az azokon végrehajtható metódu-
19
1.3. Ismerkedés a .NET keretrendszerrel
sokból áll. Felfoghatjuk egyfajta sablonként, amelyet arra használha-

tunk, hogy objektumpéldányokat hozzunk létre belőle. Amikor
programozunk, az objektumokat előbb példányosítani kell, és csak
azután használhatjuk őket. A használat ez esetben azt jelenti, hogy
kitöltjük a tulajdonságait – értéket adunk a tulajdonságokat képvise-
lő úgynevezett t a g v á l t o z ó k n a k –, és futtatjuk az osztályban
meghatározott metódusokat.
Nem tudjuk közvetlenül létrehozni az Állat objektumpéldányt.
Előbb meg kell határoznunk az Állat osztályt, az összes lehetséges tu-
lajdonságával és metódusával együtt. Az Állat osztály tehát nem egy
konkrét állatot jelképez, hanem bármelyik állatot jelentheti. Ha
használni szeretnénk az Állat osztályt, példányosítanunk kell azt,
hogy értékeket adhassunk neki és műveleteket végezhessünk rajta –
vagyis a sablon alapján létre kell hoznunk egy konkrét állatot.
1.3. Ismerkedés a .NET

keretrendszerrel
Mi a .NET?
A .NET a Microsoft előre gyártott objektumorientált környezete – tu-

lajdonképpen objektumgyűjteménye –, amely nagy segítséget nyújt a
programozóknak, mert kész megoldásokat ad az alkalmazások fej-
lesztése során felmerülő gyakori (és kevésbé gyakori) problémákra.
A programozási feladatok egyre összetettebbek, a programok
egyre bonyolultabbak, és az operációs rendszernek is egyre több
szolgáltatása van. A programozóknak, ha a hagyományos eszközö-
ket használják – a C vagy a C++ programnyelvet és az operációs
rendszer alapfunkcióit – rengeteget kell dolgozniuk az úgynevezett
20
i n f r a s t r u k t ú r a k ó d o n . Az infrastruktúrakód a programok
azon része, amely a hálózati kommunikáció, az adat- és adatbázis-
kezelés és a grafikus felhasználói felület alapelemeit valósítja meg,
de nem része, csupán alapvető, általános építőeleme a konkrét al-
kalmazáslogikának. Ha adatokat akarunk átküldeni a hálózaton, és
mondjuk csak a C++ nyelvet és a Win32-rendszert használjuk, a
konkrét adatküldéshez akár több száz programsort is le kell írnunk.
A .NET ezt az infrastruktúrakódot kínálja készen, jelentősen lerö-
vidítve a programok kifejlesztéséhez szükséges időt és csökkentve a
programfejlesztés költségét. A .NET-rendszerben egy XML-fájl beol-
vasásához, elemzéséhez és objektumként való eléréséhez egyetlen
programsort kell írni. Ha ezt az objektumot át kell küldenünk a há-
lózaton, talán már három programsort is le kell írnunk.
A keretrendszer a Windows Server 2003 óta szerves része a Win-
dowsoknak, illetve külön összetevőként korábbi operációs rendsze-
rekre letölthető, sőt bizonyos korábbi változatai akár Windows 98
alatt is futnak.
A .NET legfontosabb szolgáltatásai
Programfuttató környezet: A .NET keretrendszer programfuttató

környezet, amelynek köszönhetően sokkal könnyebb stabil, megbíz-
ható programot írni. Minden általunk írt program ebben a környe-
zetben fut. A környezet automatikus memóriakezelést biztosít, és
egyszerűsíti a rendszerszolgáltatásokhoz való hozzáférést.
HTML-fejlesztési modell (ASP.NET): A statikus HTML oldalak
unalmasak és kevéssé hatékonyak: mindig minden felhasználónak
ugyanazt a tartalmat adják vissza. Ahhoz, hogy valami változás is
történjen az oldalon, vagy a webhely tartalmát adatbázisból lehessen
szolgáltatni, kiszolgálóoldali programot kell írnunk. Az ASP.NET
környezet az Internet Information Services (IIS) webkiszolgálón fut;
21
segítségével könnyebben készíthetünk eseményvezérelt, dinamikus

HTML-lapokat, méghozzá bármely .NET-alapú programozási nyel-
ven (felügyelt C++, C#, Visual Basic.NET).
Windows-alkalmazások fejlesztése: Az asztali alkalmazásoknak
könnyen kezelhető felhasználói felülettel kell rendelkezniük. A szé-
pen megtervezett felület javítja a felhasználói élményt is: sokkal szí-
vesebben használjuk Microsoft Outlookot, mint a Hotmail webes fe-
lületét. A Microsoft .NET segítségével egyszerűbbé válik a Win-
dows-alkalmazások programozása is.
Többszálú programozás: 1993-ban, a 32-bites Windows NT meg-
jelenésével vált valóban többfeladatossá a Windows. Ennek ellenére
egész mostanáig meglehetősen nehéz volt többszálú programot írni,
mivel ezt az operációs rendszer csak korlátozottan támogatja. A .NET-
keretrendszer a korábbiaknál magasabb szintű támogatást nyújt az
operációs rendszer többszálú programfuttatási képességeinek kihasz-
nálására.
A .NET-alapú programozás
Amikor egy .NET-alapú nyelven programot írunk, majd azt lefordít-

juk, a keletkező bináris (végrehajtható) fájl nem értelmezhető közvet-
lenül az operációs rendszer számára. A .NET-alkalmazások úgyne-
vezett k ö z t e s n y e l v r e fordulnak le: ez a Common Intermediate
Language (CIL) nevet kapta. Ez már független az alkalmazott prog-
ramozási nyelvtől, tehát akár a Visual Basic.NET-ben, akár a C#-ban,
akár bármelyik másik .NET-alapú nyelven írjuk a programot, a ka-
pott kód ugyanaz lesz. Az ilyen programkódot nevezzük f e l -
ü g y e l t k ó d n a k (managed code), mivel csak a .NET-keretrendszer
programfuttató környezetének felügyelete alatt futtathatók. A prog-
ramfuttató környezet neve Common Language Runtime (CLR). Ez a
környezet nyújtja az olyan magasabb szintű szolgáltatásokat, mint
22
amilyen az automatikus memóriakezelés, benne a s z e m é t g y ű j -

t é s (garbage collection), a többszálú programfuttatás támogatása és a
kivételkezelés.
C# C#-fordító
Visual Köztes
VB-fordító nyelvű kód CLR Natív kód
Basic.NET
(CIL-kód)
Egyéb
Egyéb fordító
.NET-nyelv
1.1. ábra: A .NET-programok futtatásának sémája
Amikor elindítunk egy .NET-programot, a köztes nyelvre (CIL) le-

fordított programot a CLR futtatókörnyezet i g é n y s z e r i n t i
f o r d í t ó j a (just-in-time – JIT – compiler) n a t í v , a számítógép pro-
cesszora által értelmezhető kódra fordítja. Ez közvetlenül a program
futtatása előtt történik, ezért nagyobb .NET-alkalmazások indítása
kissé tovább tarthat, mint hasonló funkciójú natív kódban írt társaiké.
A .NET-objektumok
Most áttekintjük a .NET azon objektumait, adattípusait és a rájuk jel-

lemző metódusokat (műveleteket), amelyekre feltétlenül szükség
van a PowerShell használatához.
Mint minden programozási nyelvben, a .NET-alapú nyelvekben
is használhatunk változókat. A .NET-alapú programozási nyelvek
erősen típusosak, tehát az, hogy melyik változónak milyen értéket
23
adhatunk, a változó deklarálásakor meghatározott típusától függ. Ez

erősen érezhető, amikor valamilyen „rendes” programozási nyelvvel
(pl. C#) dolgozunk, a PowerShellben ezzel kevéssé kell foglalkoz-
nunk. Ha például egy változó típusa egész szám (integer), az csak
egész számokat tárolhat, egy karakterlánc (string) csak karaktereket,
a dátum típusú változó pedig csak dátumot.
Ezért minden objektumnak – az egész típusnak, a lebegőpontos
számoknak, a dátumoknak, sőt még a karakterláncoknak is – van
ToString metódusa, mely azt karakterlánccá alakítja. Itt jegyezzük
meg, hogy a .NET-ben minden, még a legegyszerűbb adattípus is ob-
jektumként van kezelve, vagyis például egy egész számokat tároló
változónak is vannak tulajdonságai és metódusai.
A ToString metódusnak leginkább összehasonlításkor vesszük
hasznát: például ha a ma nevű változó típusa DateTime és értéke az
aktuális dátum és idő, ezt összehasonlíthatjuk a „2000.12.31.
12:31:00” karakterlánccal. A ma==„2000.12.31. 12:31:00” kifejezés
nem ad eredményt, mivel két teljesen különböző típusú objektumot
próbálunk összevetni. Erre a helyzetre leginkább a régi favicc illik:
„Mi a különbség a krokodil között? Hosszabb, mint zöld.” Ha ered-
ményhez akarunk jutni, meg kell hívni a ma változó ToString metó-
dusát, amely a dátumból karakterláncot hoz létre az operációs rend-
szer aktuális területi beállításainak megfelelően:
ma.ToString()==„2000.12.31. 12:31:00”
Azt is megnézhetjük, hogy a ma változó Year, Month, Day stb. tulaj-

donsága megegyezik-e a kívánt értékkel (pl. ma.Year==2008).3
Több dátumból létrehozhatunk úgynevezett g y ű j t e m é n y t
(collection) is. A gyűjtemény olyan objektum, amely több más, azonos
3 Az utóbbival jobban járunk, mert a dátumok esetén a ToString() eredmé-

nye teljesen más lehet különböző nyelvi – területi – beállítások esetén, és
sok esetben nem tudjuk megjósolni, hogy a programunkat futtató Win-
dows milyen nyelvre van beállítva.
24
típusú objektumot tartalmaz. Ha a gyűjtemény neve datumok, akkor

annak egyes elemeire (melyek külön-külön önálló DateTime típusú
adatok) a datumok[0], datumok[1], datumok[2] stb. formában hivat-
kozhatunk. Vegyük észre, hogy a gyűjtemény első elemét a 0 index-
szel kell jelölni. Ilyenkor az első dátum hónap részét a
datumok[0].Month, a huszonharmadik dátum év részét pedig a
datumok[22].Year tulajdonságra való hivatkozással érjük el. Termé-
szetesen gyűjteményt nem csak dátumokból, hanem bármilyen tí-
pusból létrehozhatunk, így akár egész számokból, fájlokból vagy e-
mail címekből is.
Azt, hogy az adott gyűjteményben hány objektum található, a
Count tulajdonság adja meg, azaz a fenti példánál maradva:
datumok.Count.
25
MÁSODIK FEJEZET
Ismerkedés a PowerShellel
2.1. Telepítés
Ha a PowerShellt asztali számítógépen futtatnánk, a Windows XP-re
vagy annál újabb Windowsra van szükségünk. A Windows XP-hez
legalább a 2. szervizcsomag kell. Kiszolgálón a Windows Server 2003
első kiadására vagy annál újabb Windows-kiszolgálóra van szükség.
A Windows Server 2003 első kiadásán az 1. szervizcsomagot is tele-
píteni kell. A PowerShell emellett igényli a .NET keretrendszer 2.0
változatát.
A Windows Vista beépítve tartalmazza a .NET-keretrendszer 2.0
változatát (ehhez csak a frisssítéseket kell letölteni). A Microsoft leg-
újabb kiszolgálóoldali rendszere pedig, a Windows Server 2008, be-
építve tartalmazza a .NET-keretrendszert és a PowerShellt is, ott te-
hát semmilyen telepítésre nincs szükség (a fontos frissítéseket leszá-
mítva).
A .NET-keretrendszert és magát a PowerShellt is a Microsoft hon-
lapjáról tölthetjük le. 2008 augusztusában a .NET keretrendszer elér-
hetősége:
http://msdn.microsoft.com/en-us/netframework/aa731542.aspx
A PowerShell letöltési címe:
http://www.microsoft.com/windowsserver2003/technologies/
management/powershell/download.mspx
2.1. Telepítés
Fontos, hogy figyeljünk arra, milyen platformon kívánjuk a telepítést

végrehajtani, és az annak megfelelő fájlokat töltsük le. A .NET-
keretrendszer és a PowerShell is elérhető 32-bites (x86), 64-bites (x64)
és Itanium processzorokra is; a PowerShell letöltésekor az operációs
rendszer típusát is figyelembe kell venni.
Figyelem! A PowerShell letöltéséhez igazolni kell a futó Windows-
példány eredetiségét. Ez a letöltés előtt egy ActiveX-vezérlőelem te-
lepítését és futtatását jelenti.
A következőkben leírjuk a telepítést a könyv írásakor elérhető
platformokra:
 Windows XP és Windows Server 2003: Először telepítsük a .NET

keretrendszer 2.0 változatát. A PowerShell telepítőprogramja
azonos a Windows szokásos javítástelepítőjével. Ha a telepítőt
parancssorból indítjuk, az ott szokásos kapcsolókat is használ-
hatjuk: a /quiet megadásával a telepítés felügyelet nélküli
módban indul el. Hagyományos telepítés esetén csak a licenc-
szerződést kell elfogadnunk; a PowerShell egy-két perc alatt
települ.
 Windows Vista: Az operációs rendszer tartalmazza a .NET-

keretrendszert, úgyhogy elég a PowerShell megfelelő változa-
tát letölteni. A program egy .msu kiterjesztésű fájlban érkezik.
Az .msu a Windows Vistában és a későbbi operációs rendsze-
rekben a kézzel, nem pedig a vezérlőpult Windows Update
programjával telepíthető javítások formátuma. A telepítéshez
elég kétszer a fájl ikonjára, majd az OK gombra kattintani. A te-
lepítés külsőre olyan, mintha frissítést telepítenénk.
A PowerShell eltávolításához a vezérlőpult Programok és
szolgáltatások (Programs and features) programján belül kat-
tintsunk a Windows-szolgáltatások be- és kikapcsolása (Turn Win-
dows features on or off) hivatkozásra, majd töröljük a Windows
PowerShell összetevőt.
28
2. fejezet: Ismerkedés a PowerShellel
 Windows Server 2008: A PowerShell az operációs rendszer ré-

sze, így a Kiszolgálókezelő (Server Manager) programban a szol-
gáltatások (feature) között található, onnan telepíthető.
Ha a 32-bites változatot telepítjük, az a Windows mappán belül a

System32\WindowsPowerShell\v1.0 könyvtárba kerül, a 64-bites válto-
zat pedig a SysWOW64\WindowsPowerShell\v1.0 könyvtárba. Emellett
a telepítő a Start menüben létrehozza a Windows PowerShell 1.0 cso-
portot, és abban elhelyezi a Windows PowerShell nevű parancsikont.
A PowerShell ez utóbbival indítható.
2.2. Parancsok
Eddig, ha könyvtárlistát kértünk, azt a dir paranccsal tehettük meg;
ha az Active Directory címtárban kerestünk egy objektumot, a
dsquery parancs segített megtalálni; a szolgáltatások beállításait az sc
programmal módosíthattuk; feladatok leállítására pedig a taskkill pa-
rancsot használtuk. Látható, hogy semmilyen összefüggés nincs a
programok és parancsok nevei között.
A könnyebb megtanulás végett a PowerShell-parancsokat, ame-
lyeket p a r a n c s e l e m n e k (commandlet, röviden cmdlet) neve-
zünk, egység névkonvencióval hozták létre. A gyakorlatban ez azt je-
lenti, hogy minden parancselem egy angol igéből és egy angol fő-
névből áll, amelyeket kötőjel választ el egymástól, így: ige-főnév.
Például egy szolgáltatást a Stop-Service, egy folyamatot pedig a Stop-
Process parancselemmel állíthatunk le. A Windows-világ többi ré-
széhez hasonlóan a rendszer a parancselemek esetében sem tesz kü-
lönbséget a kis- és a nagybetűk között; ezt az írásmódot a jobb ol-
vashatóság kedvéért szokás alkalmazni.
29
2.2. Parancsok
A parancselemekben alkalmazott legfontosabb igék a következők:

Ige Általános leírás
Add Hozzáadás, például tartalom hozzáfűzése egy meglévő fájlhoz
Get Adat, beállítás lekérdezése, például egy fájl jogosultságainak kérése
New Új elem (például új fájl) létrehozása
Remove Eltávolítás, például fájl törlése
Set Beállítás, például fájl jogosultságainak beállítása
Sokszor előfordul, hogy ugyanaz a kapcsoló különböző programok

esetén teljesen különböző rendeltetéssel bír. A /s kapcsoló hatására
például a dir parancs az almappákban található fájlokat is kilistázza,
míg ugyanez a shutdown parancsot a gép leállására utasítja. Ha a /p
kapcsolót használjuk, a dir képernyőnként egy billentyű leütésére
vár, míg a taskkill parancsnak e kapcsolót követően adhatjuk meg
egy felhasználó jelszavát. Az sem mindegy, hogy a kapcsolókat ferde
törtvonal (/) vagy kötőjel (-) után adjuk-e meg, de olyan is van, hogy
egyik sem kell. Ez jelentős zavart okozhat a parancsok és paraméte-
rek értelmezésében, nehezítve megtanulásukat.
Emiatt az egyes parancselemek a r g u m e n t u m a i t (paraméte-
reit) is egységesítették: mindegyiket kötőjellel kell kezdeni és utána
értelmes, teljes angol szó áll. Rövidíthetünk is, de csak akkor, ha a
rövidítés egyértelmű. Például a -Name (név) paramétert nem rövidít-
hetjük -N-re, ha ugyanannak a parancsnak -Number (szám) argumen-
tuma is van, de a -Na már megfelel.
A PowerShellben több olyan argumentum is van, amely minden
parancselemmel használható. Ezek a következők:
Paraméter Leírás
Verbose Részletes leírást ad a parancs által elvégzett műveletről.
Debug A parancselem működéséről hibakeresési céllal nyomkövetési
(debugging) információkat ad.
30
Paraméter Leírás
ErrorAction Megadhatjuk, hogy viselkedjen a parancselem hiba esetén. A lehet-
séges beállítások: Continue (ez az alamértelmezés: folytatás, tájé-
koztat a hiba tényéről és folytatja a futást), Stop (megállás, hiba
esetén a parancselem befejezi a futást), SilentlyContinue (csend-
ben folytatja a működést, nem írja ki, hogy hiba történt, és foly-
tatja a futást), Inquire (megkérdezi, hogy kívánjuk-e folytatni a
műveletet).
ErrorVariable Az argumentum után egy változó nevét adhatjuk meg (dollárjel nél-
kül), amelybe a parancselem feljegyzi a futása során felmerülő hi-
bákat.
OutVariable A parancselem a kimenetét az argumentum után megadott változó-
ban is elhelyezi, és a csőben is továbbküldi. (A változó nevét itt is
dollárjel nélkül kell megadni.)
OutBuffer Megadhatjuk, hogy hány objektumot szeretnénk a pufferben tárolni
a csőben lévő következő parancs hívása előtt.
WhatIf Kiírja, hogy mi történne, ha a parancsot lefuttatnánk, anélkül, hogy
bármit módosítana. (Csak azokkal a parancselemekkel használható,
amelyek a rendszeren módosításokat végeznek.)
Confirm A módosítások előtt megerősítést kér. (Csak azokkal a parancsele-
mekkel használható, amelyek a rendszeren módosításokat végez-
nek.)
2.3. A legfontosabb parancselemek

A következőkben leírt öt parancs rendkívül hasznos a kezdő Power-
Shell-rendszergazdák számára.
Többször volt már szó arról, a PowerShellben is használhatjuk a
korábbról ismerős parancsokat: dir, copy, md stb. Azonban azt is állí-
tottuk, hogy a PowerShell parancselemei ige-főnév felépítésűek, mi-
közben a régi parancsok némelyike jóindulattal sem nevezhető nem-
31
2.3. A legfontosabb parancselemek
hogy igének vagy főnévnek, de szónak sem.1 Ezek azért használha-

tók mégis, mert a PowerShell kezel úgynevezett á l n e v e k e t (alias)
is. Például a dir a Get-ChildItem, a copy a Copy-Item, az md pedig a
New-Item megfelelően paraméterezett álneve. Az összes álnév listáját
a Get-Alias paranccsal kérhetjük el. Ezen a listán láthatunk egyéb ér-
dekes parancsokat is: cd: Set-Location, cls: Clear-Host stb.
Magunk is létrehozhatunk álneveket a Set-Alias parancselemmel.
A Get-Date parancselem például elkéri az aktuális rendszeridőt.
Hozzuk ehhez létre a gd álnevet: ehhez a Set-Alias gd Get-Date paran-
csot kell kiadnunk. Az álnevek lekérdezését a Get-Alias, újak felvéte-
lét pedig a Set-Alias parancselemmel végezzük.
Nehéz álneveket létrehozni, ha nem tudjuk, milyen parancsokat
használhatunk. A PowerShell által ismert parancselemeket a Get-
Command parancselem listázza ki. Ha arra vagyunk kíváncsiak, hogy
mi mindent lehet még lekérdezni (Get), akkor ezt a Get-Command
-Verb Get parancs mondja meg. Ha az érdekel bennünket, hogy a
rendszerszolgáltatásokkal milyen műveleteket végezhetünk, a Get-
Command -Noun Service parancs segít. A Get-Command parancselem-
nek helyettesítőkaraktert is megadhatunk paraméterként, akár a kö-
vetkező formában is: Get-Command Get-*, illetve Get-Command
*-Service, sőt, a Get-Command *-Co* is helyes.
Most már tudjuk, hogy milyen parancsok vannak, tanuljuk meg
használni őket! Vegyük például a Get-ChildItem parancselemet (em-
lékezzünk: ez a dir parancs új neve), majd kérjünk hozzá segítséget
így: Get-Help Get-ChildItem (a Get-Help álneve: help). Ilyenkor rövid
leírást kapunk az adott parancselemről és listát valamennyi lehetsé-
ges argumentumáról. Ha ennél több információra van szükségünk, a
Get-Help Get-ChildItem -detailed parancs hatására a PowerShell rövid
1 A régi parancsok m n e m o n i k u s a k : a m n e m o n i k olyan szócska,

amely két-három karakterben emlékeztet a parancs által végzett műveletre.
A mnemonikokat először a processzorok úgynevezett g é p i n y e l v é t
reprezentáló a s s e m b l y n y e l v e k b e n használták.(A szerk.)
32
leírást is ad minden paraméterről, és néhány egyszerűbb példán ke-

resztül elmagyarázza a parancs használatát. Ha a detailed helyett a
full kapcsolót adjuk meg, minden paraméterről részletes technikai le-
írást is kapunk: mi az alapértelmezett értékük, kötelező-e megadni
őket stb. Ha a Get-Help parancsot önmagában adjuk ki, kapunk egy
listát az összes olyan objektumról, amellyel kapcsolatban segítséget
kérhetünk: ilyenek a parancselemek, az álnevek, a súgófájlok és a
többi objektum, amelyekről még a későbbiekben szó lesz.
Ha kiadjuk a Get-ChildItem parancsot, a kimenet az alábbihoz lesz
hasonló:
2.1. példa: Könyvtárlista kiíratása

PS C:\> Get-ChildItem

---- ------------- ------ ----
d-r-- 2007.11.29. 16:51 Program Files
d-r-- 2007.11.15. 17:51 Users
d---- 2007.11.29. 16:52 Windows
-a--- 2006.09.18. 23:43 24 autoexec.bat
-ar-s 2007.09.14. 21:43 8192 BOOTSECT.BAK
-a--- 2006.09.18. 23:43 10 config.sys
Négy oszlop jelenik meg: Mode, LastWriteTime, Length és Name, ame-

lyek az adott sorban lévő, a Name oszlopba írt nevű fájlrendszerob-
jektum adott tulajdonságait jelképezi. Említettük, hogy a PowerShell
objektumorientált parancssor; ez azt jelenti, hogy az oszlopok nagy
része nem karakterlánc típusú. Felmerül az a kérdés is, hogy a fáj-
loknak vannak-e további tulajdonságaik.
A Get-Member parancs azt mondja meg, hogy a bemeneten (csö-
vezéssel) megadott objektumhalmaz milyen típusú, illetve annak mi-
lyen egyéb metódusai és tulajdonságai vannak. Így kell használni:
Get-ChildItem | Get-Member. A lista tetején látható a TypeName:
System.IO.DirectoryInfo sor, ami azt jelenti, hogy a Get-ChildItem által
33
2.4. Változók, gyűjtemények, operátorok
visszaadott gyűjtemény objektumainak típusa: DirectoryInfo. Az alat-

ta lévő táblázatban megtaláljuk többek között a LastWriteTime és a
Name tulajdonságokat, melyek típusa DateTime, illetve String, de lát-
szik a szintén DateTime típusú CreationTime tulajdonság is, amelyet
alapértelmezés szerint a Get-ChildItem parancs nem jelenít meg.
A Get-PSDrive nevű parancselem megértéséhez tudni kell, hogy a
PowerShell segítségével a b e á l l í t á s j e g y z é k b e n és a t a n ú -
s í t v á n y t á r b a n is ugyanúgy végezhetünk műveleteket, mint a
helyi fájlrendszeren, azaz a mappaváltáshoz hasonlóan válthatunk a
beállításjegyzék kulcsai között is. A PowerShell e szolgáltatását a ké-
sőbbiekben részletesebben megnézzük.
A parancsokat és argumentumaikat nem szükséges teljesen begé-
pelni: használhatjuk a Windows parancssorból is ismerős kiegészí-
tést: be kell gépelni a parancselemek vagy a paraméterek elejét (a pa-
rancselemekét legalább a kötőjelig) be kell gépelni, majd a TAB bil-
lentyű lenyomásával választhatunk a kiegészítési lehetőségek között.
2.4. Változók, gyűjtemények,

operátorok
A változók
A számítógép elsődleges feladata az adatok tárolása és feldolgozása.

Gyakran előfordul, hogy aktuális és korábban gyűjtött adatokat kell
egymással összehasonlítani. Ilyenkor a korábbi adatot valamilyen
módon tárolnunk kell. Erre a célra a PowerShellben v á l t o z ó k a t
használhatunk. A változók nevét dollárjellel ($) kell kezdeni. A név
mely betűkből és számjegyekből állhat. A változókat használat előtt
34
nem kell deklarálni, azonnal adhatunk nekik értéket.2 Az a változó-

nak adjuk az aktuális időpontot értékként: $a=Get-Date. Ha egy vál-
tozó értékére vagyunk kíváncsiak, egyszerűen csak írjuk be a nevét.
2.2. példa: Az aktuális dátum és idő változóba helyezése, majd kiíratása

PS C:\> $a=Get-Date
PS C:\> $a
2007. december 1. 13:27:26
Ezek után a b nevű változóban is helyezzük el az aktuális rendszer-

időt, majd számítsuk ki a két időpont között eltelt időt:
2.3. példa: Időértékek kivonása: két időpont között eltelt idő kiszámítása
PS C:\> $b=Get-Date
PS C:\> $b-$a
Days : 0
Hours : 0
Minutes : 3
Seconds : 16
Milliseconds : 229
Ticks : 1962298842
TotalDays : 0,00227117921527778
TotalHours : 0,0545083011666667
TotalMinutes : 3,27049807
TotalSeconds : 196,2298842
TotalMilliseconds : 196229,8842
A változóknak nemcsak parancselemek kimenetét, más változók tar-

talmát is értékül adhatjuk; példa: $c=$b, sőt, a $c=$b-$a kifejezés is
helyes. Ha ekkor a c értékét kiíratjuk, ugyanazt az eredményt kap-
juk, mint a fenti példában. Ha ezek után kiadjuk az $a=5 parancsot, a
változó elveszti korábbi értékét, új értéke értelemszerűen 5 lesz.
2 Ez a Unix-világban jól ismert P e r l vagy P H P nyelv változókezelési

szokásaihoz hasonlít.
35
Karakterláncok
Adjuk a b változónak a Most figyelj, Abu! értéket a $b=”Most figyelj,

Abu!” paranccsal.3 Ekkor a b típusa karakterlánc lesz. A karakterlán-
cokat idézőjelek (”) vagy aposztrófok (’) között kell megadni. Ezután
nézzük meg, hogy a b-nek milyen tagjai vannak:
2.4. példa: Karakterlánc metódusainak és tulajdonságainak lekérdezése

PS C:\> $b=”Most figyelj, Abu!”
PS C:\> $b | Get-Member
TypeName: System.String
Name MemberType Definition

---- ---------- ----------
Clone Method System.Object Clo...
CompareTo Method System.Int32 Comp...
Contains Method System.Boolean Co...
CopyTo Method System.Void CopyT...
EndsWith Method System.Boolean En...
Equals Method System.Boolean Eq...
GetEnumerator Method System.CharEnumer...
GetHashCode Method System.Int32 GetH...
GetType Method System.Type GetTy...
GetTypeCode Method System.TypeCode G...
get_Chars Method System.Char get_C...
get_Length Method System.Int32 get_...
IndexOf Method System.Int32 Inde...
IndexOfAny Method System.Int32 Inde...
Insert Method System.String Ins...
IsNormalized Method System.Boolean Is...
LastIndexOf Method System.Int32 Last...
LastIndexOfAny Method System.Int32 Last...
Normalize Method System.String Nor...
PadLeft Method System.String Pad...
PadRight Method System.String Pad...
Remove Method System.String Rem...
(folytatás a következő oldalon)
3 A példa forrása: Umberto Eco: A Foucault-inga. Barna Imre fordítása. Eu-

rópa, Budapest, 1992. 35. oldal.
36
(folytatás az előző oldalról)

Replace Method System.String Rep...
Split Method System.String[] S...
StartsWith Method System.Boolean St...
Substring Method System.String Sub...
ToCharArray Method System.Char[] ToC...
ToLower Method System.String ToL...
ToLowerInvariant Method System.String ToL...
ToString Method System.String ToS...
ToUpper Method System.String ToU...
ToUpperInvariant Method System.String ToU...
Trim Method System.String Tri...
TrimEnd Method System.String Tri...
TrimStart Method System.String Tri...
Chars ParameterizedProperty System.Char Chars...
Length Property System.Int32 Leng...
Ezek nagy része a karakterlánc más karakterláncokkal történő össze-

hasonlítására, illetve módosítására szolgál. Például kicserélhetjük a
karakterlánc bizonyos karaktereit:
2.5. példa: Keresés és csere karakterláncban

PS C:\> $b.Replace("e","ulla")
Most figyullalj, Abu!
Kivághatunk egy részletet belőle, mondjuk a hatodik karaktertől, tíz

karakteren keresztül. Vigyázat, a karakterek számozását 0-nál kell
kezdeni, tehát a hatodik karakter sorszáma az 5:
2.6. példa: Karakterlánc részének kivágása

PS C:\> $b.Substring(5,10)
figyelj, A
Itt az eredmény azért nem „figyullalj”, mert az előző feladatban a

módosított karakterláncot csak a képernyőre írattuk ki. Ha a parancs
elejére ezt írjuk: $b=, a „Most figyelj, Abu!”-ból a változóban is „Most
figyullalj, Abu!” lesz:
37
2.7. példa: Keresés és csere karakterláncban, majd rész kiemelése

PS C:\> $b
Most figyelj, Abu!
PS C:\> $b=$b.Replace("e","ulla")
PS C:\> $b
Most figyullalj, Abu!
PS C:\> $b.Substring(5,10)
figyullalj
Azt is ellenőrizhetjük, hogy a karakterlánc mivel kezdődik vagy mire

végződik:
2.8. példa: Karakterlánc elejének és végének vizsgálata

PS C:\> $b.StartsWith("Figy")
False
PS C:\> $b.StartsWith("Most")
True
PS C:\> $b.EndsWith("Abu!")
True
Gyűjtemények
A karakterláncot szét is darabolhatjuk egy határoló karakter, például

a szóköz mentén. Ilyenkor gyűjteményt kapunk eredményül:
2.9. példa: Karakterlánc felbontása szavakra, a szavakból gyűjtemény létrehozása

PS C:\> $c=$b.Split(" ")
PS C:\> $c
Most
figyullalj,
Abu!
PS C:\> $c.Length
3
PS C:\> $c[0]
Most
PS C:\> $c[1]
figyullalj,
PS C:\> $c[2]
Abu!
38
Ugyancsak gyűjtemény a Get-ChildItem parancs kimenete is:
2.10. példa: A könyvtárlista változóba helyezése és kezelése gyűjteményként

PS C:\> $b=Get-ChildItem
PS C:\> $b.Length
7
PS C:\> $b[1]
Directory: Microsoft.PowerShell.Core\FileSystem::C:\Users\MartonSz

---- ------------- ------ ----
d-r-- 2007.12.02. 0:35 Desktop
Gyűjteményt magunk is létrehozhatunk: ekkor a különböző értéke-

ket vesszővel kell elválasztanunk:
2.11. példa: Gyűjtemény létrehozása kézzel

PS C:\> $b="első","második","harmadik","negyedik"
PS C:\> $b
első
második
harmadik
negyedik
PS C:\> $c=8,7.2,6.3,5
PS C:\> $c
8
7,2
6,3
5
PS C:\> $d=1..3
PS C:\> $d
1
2
3
Ehhez nem feltétlenül szükséges változókat használnunk. Ha egy ka-

rakterláncot, számot vagy akár gyűjteményt begépelünk, eredmény-
ként visszakapjuk:
39
2.12. példa: Adatok megadása konstansként

PS C:\> "Most figyullakkaljAkkabu :)"
Most figyullakkalj, Akkabu :)
PS C:\> 2007
2007
PS C:\> 1,2,4
1
2
4
Műveletek, operátorok
Eddig nem nagyon dolgoztattuk a PowerShellt, pusztán adatokat

írattunk ki vele. Az adatfeldolgozáshoz számos o p e r á t o r t (mű-
veletet) használhatunk, amelyek összehasonlítások elvégzésére al-
kalmasak. Ezeket az alábbi táblázatban foglaltuk össze:
Operátor Angol neve Magyarázat

-eq Equals Egyenlő
-lt Less than Kisebb mint
-gt Greater than Nagyobb mint
-le Less than or Kisebb vagy egyenlő
equal to
-ge Greater than or Nagyobb vagy egyenlő
equal to
-not Not Logikai tagadás
-match Matches Karakterláncok vizsgálata reguláris kifejezések-
kel; igaz, ha a kifejezés benne van a karakter-
láncban
-notmatch Doesn’t match Karakterláncok vizsgálata reguláris kifejezések-
kel; igaz, ha a kifejezés nincs benne a karakter-
láncban
40
Operátor Angol neve Magyarázat

-like Is like Karakterláncok vizsgálata helyettesítő karakte-
rekkel; igaz, ha a helyettesítőkarakteres kifeje-
zés illeszkedik a karakterláncra
-notlike Is not like Karakterláncok vizsgálata helyettesítő karakte-
rekkel; igaz, ha a helyettesítőkarakteres kifeje-
zés nem illeszkedik a karakterláncra
-contains Contains Ellenőrzi, hogy egy gyűjteménynek tagja-e az
adott objektum; az eredmény igaz, ha igen
-notcontains Doesn’t contain Ellenőrzi, hogy egy gyűjteménynek tagja-e az
adott objektum; az eredmény igaz, ha nem
-replace Replace string Karakterláncok cseréje; megegyezik a karakter-
láncok Replace metódusával
-and And Logikai ÉS (logikai értékekre használható)
-or Or Logikai VAGY (logikai értékekre használható)
-band Bitwise and Bitenkénti ÉS (egész számokra használható)
-bor Bitwise or Bitenkénti VAGY (egész számokra használható)
-xor Exclusive or Kizáró VAGY
Ellenőrizhetjük, hogy jól emlékszünk-e a matematika néhány alap-

szabályára:
2.13. példa: Számok összehasonlítása
PS C:\> 3 -lt 5
True
PS C:\> 6 -ge 7
True
Ugyanez karakterláncokkal:
2.14. példa: Karakterláncok összehasonlítása

PS C:\> "kutya" -like "ut"
False
PS C:\> "kutya" -like "*ut*"
True
41

PS C:\> "kutya" -like "ku?ya"
True
PS C:\> $b -contains "második"
True
PS C:\> $b -contains "ötödik"
False
A reguláris kifejezések
A helyettesítő karakterek használatánál sokkal aprólékosabb mintail-

lesztést tesznek lehetővé a reguláris kifejezések. Ezek használatát a
következő táblázat ismerteti:
Kifejezés Magyarázat Példa

karakterek A megadott karakterek szerepelnek a ka- ”görög” -match ”rög”
rakterláncban
. Egyetlen tetszőleges karaktert helyettesít ”asztal” -match
”as..al”
[érték] A szögletes zárójelben lévő karakterek kö- ”haj” -match
zül legalább egy szerepel ”ha[jlt]”
[tartomány] A karaktertartományból legalább egy ka- ”szeg” -match ”sz[e-
rakter szerepel az eredeti karakterláncban ö]g”
[^karakterek] Bármilyen karakter, kivéve a ^ karakter ”könyv” -match
után következők (a szögletes zárójelen be- ”[^dfg]önyv”
lül)
^karakterek A karakterlánc elején lévő karakterek ”bagoly” -match
megegyeznek ”^ba”
karakterek$ A karakterlánc végén lévő karakterek meg- ”bagoly” -match
egyeznek ”ly$”
karakter* A karakterből nulla vagy annál több talál- ”asztal” -match ”s*”
ható a karakterláncban
karakter? A karakterből nulla vagy egy található a ”asztal” -match ”s?”
karakterláncban
42
Kifejezés Magyarázat Példa

karakter+ A karakterből egy vagy több található a ”xyxyxy” -match
karakterláncban ”xy+”
\karakter A karakter megtalálható a karakter- ”Próba$” -match
láncban ”Próba\$”
\w Bármilyen alfanumerikus karaktert helyet- ”abcd efgh” -match
tesít (illeszkedik rá az abcd) ”\w+”
\W Bármilyen nem alfanumerikus karaktert ”abcd efgh” -match
helyettesít (illeszkedik rá a szóköz) ”\W+”
\s Bármilyen üres karaktert helyettesít ”abcd efgh” -match
”\s+”
\S Bármilyen nem üres karaktert helyettesít ”abcd efgh” -match
”\S+”
\d Bármilyen számjegyet helyettesít 12345 -match ”\d+”
\D Bármilyen nem számjegy karaktert helyet- ”abcd” -match ”\D+”
tesít
kifejezés{n} Az előtte álló karaktert, kifejezést vagy ”abc” -match ”\w{2}”
kifejezéselemet pontosan n-szer illeszti; a
kifejezésnek megfelelő karaktersorozat-
nak n-szer kell előfordulni a karakterlánc-
ban
kifejezés{n,} Az előtte álló karaktert, kifejezést vagy ”abc” -match
kifejezéselemet legalább n-szer illeszti ”\w{2,}”
{n,m} Az előtte álló karaktert, kifejezést vagy ”abc” -match
kifejezéselemet legalább n-szer, de leg- ”\w{2,3}”
feljebb m-szer illeszti
A fenti kifejezéseket természetesen kombinálhatjuk is:
2.15. példa: Karakterláncok vizsgálata reguláris kifejezéssel

PS C:\> "abc2,4" -match "^\w{2,3}2.\d{1}$"
True
PS C:\> "sDJkf" -match "[a-zA-Z]{4}"
True
PS C:\> "sDJ7kf" -match "[a-zA-Z]{4}"
False
43
A reguláris kifejezésekhez kiterjedt matematikai és programozási

elmélet és gyakorlat tartozik. E könyv természetesen nem taníthatja
meg mindezt, az irodalomjegyzék azonban felsorol olyan műveket,
amelyekből a reguláris kifejezések részleteikben is megtanulhatók.
A feltételvizsgálat: az if operátor
A fentieken kívül van még egy operátor, amelyet nem hagyhatunk

figyelmen kívül: ez a feltételes (if) operátor. Ennek használatát a kö-
vetkező példa szemlélteti:
2.16. példa: Az if operátor használata
PS C:\> if ($b -contains "második") { "Benne van" }
Benne van
PS C:\> if ($b -contains "ötödik") { "Benne van" } else { "Nincs
benne" }
Nincs benne
Elemezzük a fenti két sort! Az első arra utasítja a PowerShellt, hogy

írja ki a „Benne van” karakterláncot, ha a $b változó értéke olyan ka-
rakterlánc, amely tartalmazza a „második” szót. Ha nem tartalmazza,
nem történik semmi.
A második sor hatására a PowerShell kiírja a „Benne van” karak-
terláncot, ha a $b változó értéke olyan karakterlánc, amely tartal-
mazza az „ötödik” szót. Ha nem tartalmazza, a PowerShell a „Nincs
benne” karakterláncot írja ki.
Az if operátor után tehát gömbölyű zárójelben megadtunk egy ki-
fejezést, amelynek eredménye Boole típusú , vagyis logikai érték
(igaz vagy hamis); itt jellemzően más operátorok eredményét hasz-
náljuk fel. Utána kapcsos zárójelek között kell megadni, hogy mi tör-
ténjen, ha az előző kifejezés igaz. Ez bármi lehet, amit a PowerShell
értelmezni tud, tehát lehet a példában is használt karakterlánc-
kiíratás, de parancselemet is futtathatunk, vagy értéket adhatunk egy
44
változónak. Ha szükséges, megadhatjuk, mi történjen, ha a feltétel

nem igaz: írjuk a sor végére az else szócskát, majd újabb pár kapcsos
zárójelben adjunk meg egy másik PowerShell-kódblokkot, amely ak-
kor fut le, ha a kifejezés hamis.
2.5. A PowerShell mint számológép

Korábban, a dátumos példa kapcsán, futólag már bemutattuk, hogy
a PowerShellt számítások elvégzésére is használhatjuk. Vegyük a
következő példát:
2.17. példa: Változók összeadása, kivonása

PS C:\> $a=5
PS C:\> $b=3
PS C:\> $a+$b
8
PS C:\> $a-$b
2
Nem kötelező változókat használnunk. A fenti példát közvetlenül

számokkal is elvégezhetjük:
2.18. példa: Számkonstansok összeadása, kivonása

PS C:\> 7+5
12
PS C:\> 8*3
24
Sőt, bonyolultabb műveleteket is végrehajthatunk:
2.19. példa: Bonyolultabb aritmetikai műveletek

PS C:\> 8+4*(3+5)/7
12,5714285714286
PS C:\> $a*7-2*($b+1)
27
45
2.5. A PowerShell mint számológép
Megjegyezzük, hogy az összeadás (+) művelet karakterláncokon is

értelmezhető: karakterláncok összefűzésére használható.
Vannak olyan műveletek, amelyeket önmagában PowerShellel
nem tudunk elvégezni, de mivel ez a parancssor a .NET keretrend-
szerre épül, felhasználhatjuk a .NET metódusait és tulajdonságait. A
számológép példájánál maradva: PowerShellben nincs lehetőségünk
négyzetgyököt vonni, ellenben .NET-ben van erre szolgáló metódus:
a System névtér Math osztályának Sqrt metódusa.
2.20. példa: .NET-függvények hívása számítási műveletekhez; négyzetgyök

PS C:\> [System.Math]::Sqrt(25)
5
A .NET-osztály nevét szögletes zárójelek között kell megadni, majd

két kettőspont után jön a metódus neve. Ezt követik a metódus ar-
gumentumai, gömbölyű zárójelek között. Nem kell programozónak
lennünk, hogy ilyen megoldásokat használjunk: ha ellátogatunk a
http://msdn.microsoft.com webhelyre, és ott a keresőben angol tősza-
vakkal körülírjuk a kívánt funkciót, a keresés eredményeként való-
színűleg megkapjuk a szükséges metódust vagy tulajdonságot. Te-
gyünk egy próbát! Írjuk a keresőbe a „pi” kifejezést; a találati listában
látjuk, hogy a System.Math osztálynak van egy Pi nevű tulajdonsága:4
4 Előfordulhat, hogy a keresőben az eredmények finomítása végett még rá

kell kattintani a .NET osztálytár (.NET Class Library) hivatkozásra is, amely
közvetlenül a keresőmező alatt található.
46
2.1. ábra: A System.Math osztály Pi tulajdonságának megkeresése az MSDN

tudástárában
Próbáljuk ki:
2.21. példa: A pi () konstans előhívása a .NET-osztálytárból

PS C:\> [System.Math]::Pi
3,14159265358979
Számoljuk ki egy 3 egység sugarú kör kerületét:
2.22. példa: Kör sugarának kiszámítása

PS C:\> 2*3*[System.Math]::Pi
18,8495559215388
47
2.6. Ciklusok
2.6. Ciklusok
Számos esetben szükség lehet arra, hogy egy feladatot egymás után
többször elvégezzünk, ám nem túl hatékony, ha ugyanazt a paran-
csot több százszor leírjuk egymás után, esetleg kisebb módosítással.
Inkább bízzuk ezt is a számítógépre! Ha már az ismétlődő műveletek
elindítása előtt tudjuk, hogy hányszor kívánjuk lefuttatni az adott
parancsot, használhatjuk a for utasítást:
2.23. példa: A for ciklus

PS C:\> for ($i=1;$i -le 3;$i++) { $i }
1
2
3
Nézzük meg, hogy mi történt! A for utasítás után sima zárójelben há-
rom dolgot kell megadni, ezeket pedig pontosvesszővel kell elvá-
lasztani: 5
1. Választani kell egy változót, és annak meg kell adni a kezdeti ér-
tékét. Ez lesz a ciklus kezdőértéke. Most az i változónak adjuk az
1 értéket.
2. Meg kell adni egy feltételt, ameddig a parancsot ismételni akar-
juk. Itt addig ismétlünk, amíg az i értéke kisebb, vagy egyenlő há-
rommal.
3. Utasítást kell adni, mi történjen az egyes ismétlések után. Most
eggyel növelni kell az i változó értékét. Ha ezt nem tennénk meg,
a ciklus a végtelenségig futna, vagyis addig, amíg i értéke nem
nagyobb, mint 3, de mivel i értékét nem változtatjuk, a ciklus so-
ha sem érne véget.
5 A PowerShell for utasítása a C/C++ nyelv logikáját követi, és eltér a

VBScript vagy a Visual Basic logikájától. A C/C++ nyelvről az irodalom-
jegyzékben felsoroltunk néhány könyvet.
48
Ezek után kapcsos zárójelek között közölnünk kell a PowerShell-lel,

hogy milyen műveletet ismételjen a ciklus. A példában az egyszerű-
ség kedvéért csak kiíratjuk i értékét, de több parancsot is futtatha-
tunk egy ciklus alatt; ha több utasítást adunk meg, azokat pontos-
vesszővel kell elválasztani egymástól.
A fenti paramétereket tetszés szerint módosíthatjuk, így a követ-
kező példa is helyes:
2.24. példa: A ciklusváltozó módosítása a for ciklus magjában
PS C:\> for ($i=3; $i -ge 1; $i--) { $i; 2*$i }
3
6
2
4
1
2
Itt háromtól számoltattunk vissza egyig, majd az éppen aktuális

számot és annak kétszeresét is kiírtuk.
Vegyük azt a példát, hogy egy weboldalról szeretnénk letölteni
100 képet, amelyek nevében csak a sorszám különbözik. Ehhez szük-
ség lesz egy parancssori letöltő programra (például: wget). A wget
számos helyről beszerezhető; e könyv szerzője a
http://users.ugent.be/~bpuype/wget/
oldalról szokta letölteni. Ha a képek a http://www.honlap.hu/kepek/

nnn.jpg címen vannak, ahol nnn a kép sorszámát jelöli, a következőt
kell beírni:
2.25. példa: Sok kép automatikus letöltése egy webhelyről

for ($i=1;$i -le 100;$i++) { wget
http://www.honlap.hu/kepek/$i.jpg }
Előfordulhat, hogy nem tudjuk előre, egy adott parancsot hányszor

kell lefuttatni. Ilyenkor a while utasítást használhatjuk valamilyen
formában: létezik elöl tesztelő és hátul tesztelő változata. Az elöl
49
2.6. Ciklusok
tesztelő változat az ismétlődő utasítás megkezdése előtt, a hátul tesz-

telő pedig az utasítás lefuttatása után ellenőrzi, fennállnak-e még a
ciklus futtatásának feltételei.
Az elöl tesztelő változatban előfordulhat, hogy a ciklus egyszer
sem fut le, ha a feltétel már kezdetben hamis, míg a hátul tesztelő
változat legalább egyszer mindenképpen végrehajtja a kért művele-
tet.
Az elöl tesztelő while ciklust például így használhatjuk:
2.26. példa: Számok beolvasása a billentyűzetről, amíg a felhasználó 0-t nem gépel
PS C:\> $a=-1
PS C:\> while ($a -ne 0) { $a=Read-Host }
A Read-Host parancselem egy sort olvas be a billentyűzetről. A ciklus

addig fut (addig olvas be újabb és újabb számokat a billentyűzetről),
amíg 0-t nem írunk be. A parancs előtt azért adtuk az a változónak a
-1 értéket, hogy a while ciklus akkor is működjön, ha a változó ko-
rábban már létezett, és éppen 0 volt az értéke.
Ha az első lépést ki szeretnénk hagyni, de azt akarjuk, hogy a pa-
rancs legalább egy értéket beolvasson, a hátul tesztelő változatot kell
használnunk. Ehhez a kapcsos zárójeles rész után kell a while utasí-
tást és a hozzá tartozó feltételt megadni (gömbölyű zárójelben).
Azonban ilyenkor tudatnunk kell a PowerShellel, hogy nem „csak
úgy” kezdtük el írni az utasításokat, hanem azok után még jön egy
while is. Erre a do szócskával utalhatunk:
2.27. példa: Számok beolvasása a billentyűzetről, amíg a felhasználó 0-t nem gépel;
hátul tesztelő while ciklussal
PS C:\> do { $a=Read-Host } while ($a -ne 0)
1
2
3
0
50
(A fenti példában a számokat nem a parancs írta ki, hanem mi vittük

be a billentyűzetről, a ciklus pedig csak a 0 után lépett ki.)
Mint már említettük, ilyenkor teljesen mindegy, hogy előtte mi
volt az a változó tartalma, ugyanis még az ellenőrzés előtt átírtuk az
értékét a Read-Host által szolgáltatott adattal.
2.7. Objektumok kezelése

Eddig nem kezeltük a gyűjtemények egészét, csak a bennük levő kü-
lön értékeket. Azonban az esetek többségében nem elszigetelt, kü-
lönálló adatokkal kell dolgoznunk, hanem több száz, vagy akár több
ezer elemből álló adattömegekkel. Ehhez a PowerShell számos objek-
tumkezelő parancselemet kínál. Ezeket onnan lehet felismerni, hogy
a főnévi részük Object (*-Object). Úgy szokás ezeket használni, hogy
„beléjük csövezzük” az adatokat, vagyis az ilyen parancselemek be-
menete általában más parancselemek kimenete. A következőkben
ismertetjük a legfontosabb objektumkezelő parancselemeket. Igye-
keztünk ezeket gyakorisági sorrendbe rendezni; a lista a leggyakorib
parancselemmel kezdődik:
Where-Object: Objektumok szűrése megadott feltételek alapján.
Válasszuk ki a könyvtárlistából az 1 MB-nál nagyobb fájlokat:
2.28. példa: Válogatás a könyvtárlistából a Where-Object parancselemmel
PS C:\Windows> Get-ChildItem | Where-Object { $_.Length -gt 1MB }
Directory: Microsoft.PowerShell.Core\FileSystem::C:\Windows

---- ------------- ------ ----
-a--- 2006.11.02. 10:45 2923520 explorer.exe
-a--- 2007.12.03. 22:21 1349335 WindowsUpdate.log
51
A Where-Object parancselem után kapcsos zárójelben kell megadni a

szűrési feltételt. A parancs „végigmegy” a gyűjtemény összes objek-
tumán, és csak azokat küldi tovább a saját kimenetére, amelyekre a
feltétel igaz. A $_ speciális változóban mindig az aktuális objektum
található, a szűrési feltételeket mindig erre a változóra kell megadni.
A parancsok egyszerűsítése és rövidítése végett a leggyakrabban
használt informatikai mértékegységeket közvetlenül is használhatjuk
a PowerShellben:
2.29. példa: Mennyiségek megadása mértékegységgel (KB, MB, GB)
PS C:\Windows> 5KB
5120
PS C:\Windows> 3.6MB
3774873,6
PS C:\Windows> 2.1GB
2254857830,4
Ha egy könyvtárban a .txt kiterjesztésű fájlokat keressük, azt egysze-

rűen a Get-ChildItem *.txt paranccsal is megtehetjük. Azonban csak
reguláris kifejezést alkalmazhatunk6, ha azokra a fájlokra vagyunk
kíváncsiak, amelyek a vagy b betűvel kezdődnek, azután öt nem
szám karakter következik, majd két számjegy és három karakterből
álló kiterjesztésük van (példa: bpwsl08.xml):
6 A következő oldalon látható reguláris kifejezés magyarázata:

 ^[ab] – a név a vagy b betűvel kezdődik, a ^ után egy karakter helyett
halmazt adtunk meg (az [ab] azt jelenti, hogy „a vagy b”).
 \D{4} – a név négy karakterrel folytatódik, amelyek közül egyik sem
számjegy. A \D jelentése: „nem számjegy”, a {4} pedig azt jelenti, hogy
„a megelőző karakterből vagy kifejezésből négynek kell ismétlődnie.
 \d{2} – a név két számjeggyel folytatódik. A \d jelentése: „számjegy”, a
{2} pedig azt jelenti, hogy „a megelőző karakterből vagy kifejezésből
kettőnek kell ismétlődnie.
 \. – egy pont.
 .{3}$ – tetszőleges karakter (ezt jelöli a „.”), háromszor, a név végén
(ezt írja elő a $).
52
2.30. példa: Könyvtárlista összegyűjtése alkönyvtárakból is; meghatározott nevű fáj-

lok kiválogatása a Where-Object parancselemmel és reguláris kifejezésekkel
Get-ChildItem -Recurse -Force | Where-Object { $_.Name -match
"^[ab]\D{4}\d{2}\..{3}$" }
A Get-ChildItem -Recurse argumentuma nem csak az aktuális map-

pában, hanem annak almappáiban is listázza a fájlokat, a Force pa-
raméter pedig a rejtett fájlokat is megjeleníti.
Természetesen dolgozhatunk kézzel létrehozott gyűjteménnyel is:
2.31. példa: Kézzel létrehozott gyűjtemény szűrése a Where-Object parancselemmel
PS C:\Windows> "első","második","harmadik","negyedik" | Where-
Object { $_ -match "m" }
második
harmadik
ForEach-Object: Művelet elvégzése a gyűjteményben levő valameny-

nyi objektumon. Adjuk most össze az aktuális mappában levő fájlok
méretét (bájtban) egy változóban, majd írassuk ki annak tartalmát:
2.32. példa: Az aktuális mappában levő fájlok méretének összegzése
PS C:\Windows> Get-ChildItem | ForEach-Object { $osszeg+=$_.Length }
PS C:\Windows> $osszeg
6836671
A rendszer a Get-ChildItem parancselem által visszaadott gyűjtemény

összes objektumán végrehajtja a ForEach-Object parancs után kap-
csos zárójelek között található utasítást vagy utasításokat. Kezdetben
az osszeg változónak nem volt értéke. A kapcsos zárójelek között lé-
vő kifejezés az $osszeg=$osszeg+$_.Length parancs C-stílusban rövi-
dített változata, ahol az egyenlőségjel bal oldalán lévő változót nem
írjuk ki még egyszer annak jobb oldalán, és az operátort (az össze-
adás jelet) az egyenlőségjel elé visszük. Ugyanilyen formában a ki-
vonást, a szorzást és az osztást is elvégezhetjük, ha a megfelelő ope-
rátort írjuk a pluszjel helyett.
53
Vegyük észre, hogy az osszeg változónak nem adtunk értéket a

művelet megkezdése előtt; a változó akkor jött létre, amikor a
$osszeg+=$_.Length utasítás először végrehajtódott. A PowerShell a
szám típusú változóknak létrehozáskor a 0 értéket adja, szemben
például a C nyelvvel, ahol a változók értéke mindaddig meghatáro-
zatlan, amíg először értéket nem kapnak.
Az előző példánál kicsit bonyolultabb, ha a fájlok méretének át-
lagára vagyunk kíváncsiak. Ennek kiszámítására alapértelmezés sze-
rint nincs lehetőségünk, úgyhogy valamiféle kerülő megoldáshoz
kell folyamodnunk: az előző példához hasonlóan összeszámoljuk a
fájlok méretét, valamint egy másik változóban a számukat, a végén
pedig e kettőből kiszámoljuk az átlagot:
2.33. példa: Az aktuális mappában levő fájlok átlagos méretének kiszámítása
PS C:\Windows> Get-ChildItem | ForEach-Object {
$osszeg+=$_.Length; $szam+=1 }
PS C:\Windows> $osszeg/$szam
63324,9166666667
Semmi akadálya nincs annak, hogy egy utasításban akár többször is

csövezzünk, így ha az .exe kiterjesztésű fájlok méretére vagyunk kí-
váncsiak, a következőképp tehetjük meg:
2.34. példa: Az aktuális mappában levő *.exe fájlok méretének összegzése
PS C:\Windows> Get-ChildItem | Where-Object { $_.Name.EndsWith(".exe")
} | ForEach-Object { $exemeret+=$_.Length }
PS C:\Windows> $exemeret
4177376
A Get-ChildItem eredményéül kapott gyűjteményéből a Where-Object

segítségével kiválasztottuk az .exe kiterjesztésű fájlokat. Ehhez azt
használtuk fel, hogy a Get-ChildItem FileInfo objektumainak Name tu-
lajdonsága karakterlánc típusú, amelyhez rendkívül jól használható
metódusok tartoznak. Ilyen az EndsWith, amelynek visszatérési érté-
ke Boole (logikai) típusú, és azt adja meg, hogy a karakterlánc az
54
EndsWith argumentumaként megadott karaktersorozatra végződik-e.

Figyeljük meg, hogy míg az első fejezetben bemutatott VBscript-kód
13 sorból állt, a PowerShellben ugyanennek a műveletnek az
elvégézéshez egy sor kellett, három parancselemmel.
Sort-Object: Objektumok rendezése valamely tulajdonságuk alapján,

növekvő vagy csökkenő sorrendbe.
Észrevehettük már, hogy a könyvtárlistát nem betűrendben kap-
juk vissza, viszont mi, emberek, könnyebben eligazodunk egy olyan
adathalmazban, amely valamilyen logika szerint rendezve van. A
gyűjteményeket a Sort-Object parancselemmel rendezhetjük sorba.
Kezdjük a könyvtárlistával:
2.35. példa: A könyvtárlista kiíratása név szerinti ábécésorrendben
PS C:\> Get-ChildItem | Sort-Object Name

---- ------------- ------ ----
d-r-- 2007.10.23. 18:28 Contacts
d-r-- 2007.12.05. 20:36 Desktop
d-r-- 2007.10.22. 16:01 Downloads
d-r-- 2007.11.30. 20:36 Favorites
d-r-- 2007.10.22. 16:01 Links
d-r-- 2007.10.22. 16:01 Saved Games
d-r-- 2007.10.22. 16:01 Searches
A parancselem után meg kell adnunk annak a tulajdonságnak a ne-

vét, amely szerint növekvő sorrendbe szeretnénk rendezni az eleme-
ket. Most a fájlok neve (Name) alapján rendeztünk. Ha csökkenő sor-
rendet szeretnénk kapni, a tulajdonság után a -Descending kapcsolót
is írjuk be! Íme a lista rendezése az utolsó módosítás ideje – a
LastWriteTime tulajdonság – szerint csökkenő sorrendben:
55
2.36. példa: A könyvtárlista kiíratása az utolsó módosítás ideje szerinti fordított idő-
rendben
PS C:\> Get-ChildItem | Sort-Object LastWriteTime -Descending

---- ------------- ------ ----
d-r-- 2007.12.05. 20:36 Desktop
d-r-- 2007.11.30. 20:36 Favorites
d-r-- 2007.10.23. 18:28 Contacts
d-r-- 2007.10.22. 16:01 Links
d-r-- 2007.10.22. 16:01 Searches
d-r-- 2007.10.22. 16:01 Saved Games
d-r-- 2007.10.22. 16:01 Downloads
Select-Object: Objektum vagy objektumok kiválasztása bizonyos tu-

lajdonságaik alapján. Például megkereshetjük a mappa öt legkisebb
fájlját, de ehhez a listát először méret alapján növekvő sorrendbe kell
rendezni:
2.37. példa: Az aktuális mappában levő 5 legkisebb fájl kilistázása
PS C:\Windows> Get-ChildItem | Sort-Object Length | Select-Object
-First 5

---- ------------- ------ ----
-a--- 2007.09.20. 7:22 0 setuperr.log
-a--- 2007.12.04. 8:02 12 bthservsdp.dat
-a--- 2007.08.26. 8:59 39 vbaddin.ini
-a--- 2007.09.15. 23:02 69 NeroDigital.ini
-a--- 2006.11.02. 13:48 94 SETUPAPI.LOG
Ha egy lista első öt eleme helyett az utolsó öt elemre vagyunk kíván-

csiak, a -First paraméter helyett a -Last paramétert kell megadni.
Megkereshetjük a három legrégebben használt fájlt:
56
2.38. példa: Az aktuális mappában levő 3 legrégebben módosított fájl kilistázása

PS C:\Windows> Get-ChildItem | Sort LastWriteTime | Select -First
3

---- ------------- ------ ----
-a--- 2002.02.18. 6:35 6550 jautoexp.dat
-a--- 2002.02.18. 9:23 46352 setdebug.exe
-a--- 2006.09.18. 23:30 1405 msdfmap.ini
A Select-Object parancs másik gyakori felhasználási módja az, ami-

kor egy gyűjteményből szeretnénk a benne szereplő többször előfor-
duló elemek közül kizárólag az egyiket kiválasztani:
2.39. példa: Gyűjtemény ismétlődő elemeinek kihagyása
PS C:\Windows> "a","c","b","a","b","a" | Select-Object -Unique
a
c
b
Tehát az a és b elemek többször is előfordultak a példában szereplő

listában, de a Select-Object parancselem olyan gyűjteményt ad vissza,
amelyben minden, eredetileg ismétlődő elem csak egyszer szerepel.
Group-Object: Objektumok csoportosítása megadott tulajdonságok
szerint. A parancselem arra nyújt lehetőséget, hogy például egy
mappa fájljait kiterjesztésük szerint csoportosítsuk, majd a csoporto-
kat külön gyűjteményként kezeljük:
2.40. példa: Könyvtárlista mint gyűjtemény elemeinek csoportosítása a fájlok kiter-
jesztése szerint
PS C:\Windows> Get-ChildItem | Group-Object Extension
Count Name Group

----- ---- -----
57 {addins, AppPatch, assembly, Boot...}
1 .NET {Microsoft.NET}
57

8 .PIF {ARJ.PIF, LHA.PIF, NOCLOSE.PIF,
PKUNZIP.PIF...}
12 .exe {bfsvc.exe, explorer.exe, fveupdate.exe,
HelpPane.exe...}
3 .dat {bootstat.dat, bthservsdp.dat, jautoexp.dat}
3 .xml {diagerr.xml, diagwrn.xml, Enterprise.xml}
12 .log {DirectX.log, DPINST.LOG, DtcInstall.log,
msxml4-KB936181-enu.LOG...}
1 .bin {mib.bin}
6 .ini {msdfmap.ini, NeroDigital.ini, ODBC.INI,
system.ini...}
1 .rnd {randseed.rnd}
1 .etl {SPInstall.etl}
2 .dll {twain.dll, twain_32.dll}
1 .prx {WMSysPr9.prx}
Annak bizonyítására, hogy a Group oszlopban lévő adatok valóban

gyűjtemények, írassuk ki az egyes gyűjtemények méretét:
2.41. példa: Az egyes csoportok elemeinek megszámolása csoportosított gyűjtemény-
ben (most épp könyvtárlistában)
PS C:\Windows> Get-ChildItem | Group-Object Extension | ForEach-
Object { $_.Name+" kiterjesztéssel "+$_.Group.Count+" fájl talál-
ható" }
kiterjesztéssel 57 fájl található
.NET kiterjesztéssel 1 fájl található
.PIF kiterjesztéssel 8 fájl található
.exe kiterjesztéssel 12 fájl található
.dat kiterjesztéssel 3 fájl található
.xml kiterjesztéssel 3 fájl található
.log kiterjesztéssel 12 fájl található
.bin kiterjesztéssel 1 fájl található
.ini kiterjesztéssel 6 fájl található
.rnd kiterjesztéssel 1 fájl található
.etl kiterjesztéssel 1 fájl található
.dll kiterjesztéssel 2 fájl található
.prx kiterjesztéssel 1 fájl található
Compare-Object: Két objektum összehasonlítása. Itt a parancselem

használatát csak röviden ismertetjük, bővebben a 4. fejezetben (A
fájlrendszer kezelése) szólunk róla.
58
Helyezzük el az éppen futó folyamatok listáját egy változóban,

indítsunk el a notepad.exe (Jegyzettömb) programot, majd kérdez-
zük le ismét, hogy melyek az aktuális folyamatok, és hasonlítsuk
össze a két változót:
2.42. példa: Két gyűjtemény összehasonlítása; folyamatok listájának változóba helye-
zése és az újonnan elindított folyamatok észlelése
PS C:\Windows> $folyamatok1=Get-Process
PS C:\Windows> notepad
PS C:\Windows> $folyamatok2=Get-Process
PS C:\Windows> Compare-Object $folyamatok1 $folyamatok2
InputObject SideIndicator
----------- -------------
System.Diagnostics.Process (notepad) =>
Nem meglepő, hogy a két lista között egyedül a notepad nevű folya-
mat a különbség. Ez az információ az InputObject mezőben található,
azt pedig, hogy melyik listában van benne, a SideIndicator mutatja.
Ebben az esetben egy jobbra mutató nyilat látunk, vagyis a Compare-
Object paraméterei között másodikként megadott gyűjteményben
van benne a notepad.exe.
Megjegyezzük, hogy a Where-Object, ForEach-Object, Select-
Object és Group-Object parancselemeket az -Object utótag nélkül is
használhatjuk, mivel alapértelmezés szerint léteznek hozzájuk a
where, foreach, select és group álnevek.
2.8. A kimenet formázása

A .NET-keretrendszernek köszönhetően a PowerShell objektumori-
entált parancssor. Csövezéskor a különböző parancselemek objek-
tumokat adnak át egymásnak, és ezekből az objektumokból csak a
parancs legvégén, az adatok kimenetre (képernyőre, fájlba, nyomta-
59
tóra stb.) írásakor lesz szöveg. A kimeneten alapértelmezés szerint

nem látjuk az objektumok valamennyi tulajdonságát. Ezért meghatá-
rozhatjuk, mit, hogyan és milyen részletességgel szeretnénk kiíratni.
A Format parancselemek
Minden parancsnak van alapértelmezett kimeneti formátuma.

Könyvtárlista esetén például táblázatos formában kapjuk meg az
adatokat. Ha ez az adott feladathoz nem felel meg, vagy épp a for-
mátum jó, csak több adatot szeretnénk látni, használhatjuk a Format-
Table (álneve: ft) és a Format-List (álneve: fl) parancselemeket. Ezek
az egyes objektumok tulajdonságait egy sorban (táblázatszerűen), il-
letve egymás alatt több sorban (listaszerűen) jelenítik meg. A pa-
rancselemek argumentumaként megadhatunk egy listát (vesszővel
elválasztva), hogy mely tulajdonságokat, milyen sorrendben kívá-
nunk megjeleníteni. Jelenítsük most meg a könyvtárlistát olyan táb-
lázatban, ahol csak a bejegyzések neve és létrehozásuk ideje szerepel!
2.43. példa: A könyvtárlista átformázása táblázatként
PS C:\> Get-ChildItem | Format-Table Name,CreationTime
Name CreationTime
---- ------------
Contacts 2007.09.14. 12:50:44
Desktop 2007.09.14. 12:50:24
Documents 2007.11.07. 17:02:56
Downloads 2007.09.14. 12:50:24
Favorites 2007.09.14. 12:50:24
Links 2007.09.14. 12:50:24
Pictures 2007.09.14. 12:50:24
Saved Games 2007.09.14. 12:50:24
Searches 2007.09.14. 12:50:53
Tracing 2007.09.14. 14:11:52
Videos 2007.09.14. 12:50:24
60
Ha a fenti parancsban felcseréljük a Name és CreationTime tulajdon-

ságokat, az oszlopok a képernyőn is fordított sorrendben jelennek
meg. Ha a Format-Table parancselemhez megadjuk a -AutoSize pa-
ramétert is, az automatikusan átméretezi a táblázatot, hogy abban ne
legyen fölösleges üres hely az oszlopok között.
Ha táblázat helyett listát szeretnénk kapni, a következőt kell beírni:
2.44. példa: A könyvtárlista átformázása listaként
PS C:\> Get-ChildItem | Format-List
Name : Contacts
CreationTime : 2007.09.14. 12:50:44
LastWriteTime : 2007.11.13. 22:23:27
LastAccessTime : 2007.11.13. 22:23:27
Name : Desktop
CreationTime : 2007.09.14. 12:50:24
LastWriteTime : 2007.12.06. 12:35:12
LastAccessTime : 2007.12.06. 12:35:12
...
(A példából a többi elem listaszerű felsorolását a hely kímélése vé-

gett kivágtuk.)
A Format-Table és Format-List parancselemek paramétereként
bármilyen tulajdonságot megadhatunk, amely elérhető a Get-Member
(jelen esetben a Get-ChildItem | Get-Member) parancselem kimeneté-
ben.
Az Out parancselemek
Eddig minden kimenet a képernyőre került, de sokszor lehet szüksé-

günk arra, hogy az eredményt meg is örökítsük valamilyen formá-
ban, akár úgy, hogy fájlba mentjük, akár úgy, hogy nyomtatóra küld-
jük. Ha egy cső végén nem adjuk meg, hogy mi történjen az adatok-
61
kal, azt a rendszer úgy értelmezi, hogy a képernyőre szeretnénk kiírat-

ni, vagyis automatikusan elküldi őket az Out-Host parancselemnek.
Emlékezzünk vissza a Read-Host parancselemre, amely a billen-
tyűzetről olvas be egy sort! Ebből már rájöhetünk, hogy a *-Host pa-
rancsok az interaktív (képernyős-billentyűzetes) be- és kiviteli műve-
letekért, a felhasználóval való kommunikációért felelősek.
Ha a képernyő helyett egy parancs kimenetét szöveges fájlba sze-
retnénk írni, az Out-File parancselemet kell használnunk, paraméter-
ként megadva a fájl nevét. Alapértelmezés szerint a parcsnelem fe-
lülírja a célfájlt, ha az már létezik. Ha az új eredményt a meglévő tar-
talom végére szeretnénk írni, használjuk az -Append argumentumot is!
Az alapértelmezett nyomtatóra is küldhetünk adatokat az Out-
Printer parancselemmel; ha más nyomtatót szeretnénk használni, ad-
juk meg paraméterként annak nevét!
Az Export parancselemek
Ha egy objektumot úgy szeretnénk tárolni, hogy azt később bármi-

kor elővehessük, és gyűjteményként műveleteket végezhessünk raj-
ta, az Out-* cmdletek helyett az Export-Csv vagy Export-Clixml paran-
csokat kell használnunk. Ezek egy csv (comma separated values, vesz-
szővel tagolt értékek7), illetve XML formátumban írják ki a nekik át-
adott objektumot. Ehhez például a Get-ChildItem | Export-Csv
fajlok.csv, vagy a Get-ChildItem | Export-Clixml fajlok.xml utasításokat
használhatjuk. Az így kimentett adatok beolvasását csak később, a 4.
fejezetben, a fájlok kezelésénél tárgyaljuk.
7 A .csv fájlok elválasztó karaktere csak az operációs rendszer angolszász

nyelvi beállítása mellett a vessző. Ha a Windowst magyar területre állítot-
tuk be, akkor a pontosvesszőt használja.
62
Formázás az -f operátorral
A negyedik, legrugalmasabb, de egyben legbonyolultabb formázási

lehetőség az -f operátor. Ezzel megadhatjuk az egyes oszlopok szé-
lességét, azt, hogy az adott mezőt jobbra vagy balra szeretnénk-e
zárni, valamint a mező formátumát.
Az utóbbit így kell használni: idézőjelek között (karakterláncként)
meg kell adni a formázási utasításokat, ezután az -f operátort, majd a
formázandó adatokat, vesszővel elválasztva.
2.45. példa: Adatmezők formázása az -f operátorral
PS C:\Users\MartonSz\Desktop> "{0,-10} {1,-15} {2,5}" -f
"hello","vilag!",4014
hello vilag! 4014
A formázási utasításokat a következőképp kell értelmezni: a kapcsos

zárójelek mind egy-egy értéket jelképeznek. Az értéken belül az első
szám azt jelöli, hogy arra a helyre az -f operátor után található lista
melyik elemét kell beilleszteni (a 0 jelenti az első értéket), a második
számmal pedig az oszlopszélességet (padding) adhatjuk meg. A példa
első értéke a {0,-10}, vagyis az első paramétert („hello”) egy 10 ka-
rakter széles oszlopban helyezzük el, és balra zárjuk: ezt jelenti a mí-
nuszjel. Ha ehelyett a {0,10} értéket írjuk, a „hello” szöveg jobbra
zárva jelenik meg:
2.46. példa: Adatok formázása jobbra zárva az -f operátorral
PS C:\Users\MartonSz\Desktop> "{0,10} {1,-15} {2,5}" -f
"hel-lo","vilag!",4014
hello vilag! 4014
Az oszlopokat fel is cserélhetjük, a formázó utasításokat pedig kiegé-

szíthetjük statikus (állandó) szöveggel is. Ekkor:
63
2.47. példa: Formázósablon alkalmazása az -f operátorral

PS C:\Users\MartonSz\Desktop> "Ez egy szám: {2,10} Ezek meg betűk:
{0,-15}, sőt ezek is: {1,5}" -f "hello","vilag!",4014
Ez egy szám: 4014 Ezek meg betűk: hello , sőt ezek
is: vilag!
Figyeljük meg, hogy csak a formázó karakterláncot módosítottuk!

A formázott értékek csak akkor tudnak táblázattá összeállni, ha
több elemet is feldolgozunk, viszont az -f operátor egyszerre csak
egy sornyi adattal tud dolgozni. Ilyen esetben hívjuk segítségül a
ForEach-Object parancselemet, majd azzal soronként írassuk ki az ob-
jektumokat:
2.48. példa: Könyvtárlista formázása táblázatként az -f operátorral
PS C:\Users\MartonSz\Desktop\PS> Get-ChildItem | ForEach-Object {
"{0,-20} {1,10}" -f $_.Name,$_.Length }
0___Tartalom.doc 128000
800px-CLRdiag.png 29190
CLR-Wp.mht 281698
PS-TOC - num.docx 21941
PS-TOC.docx 22846
ps1.docx 39496
ps2.docx 60291
Ám az -f operátor más átalakításokat is el tud végezni: nem korláto-

zódik táblázatos adatok formázására. Az értékek hivatkozását a
{0,0:n} formában is meg lehet adni, ahol az n az átalakítás típusát je-
lenti. Megjegyezzük, hogy a {0}, illetve a {0:n} formátum is helyes,
ugyanis a kitöltést jelző számot (a vesszővel együtt) elhagyhatjuk.
Ilyen esetben az operátor nem végez kitöltést, csak az értéket illeszti
be az adott helyre, az esetleges átalakítások elvégzése után. Az aláb-
biakban egy-egy példán keresztül áttekintjük az átalakításokat:
Hexadecimális:
2.49. példa: Számok kiíratása 16-os számrendszerben
PS C:\> "{0:x}" -f 510
1fe
64
Amennyiben az x helyett X-et írunk (nagybetűvel), a hexadecimális

számjegyeket is nagybetűvel jeleníti meg:
2.50. példa: Számok kiíratása 16-os számrendszerben, nagybetűkkel
PS C:\> "{0:X}" -f 510
1FE
Itt is használhatunk kitöltést:

2.51. példa: Számok kiíratása 16-os számrendszerben, jobbra zárva
PS C:\> "{0,10:X}" -f 510
1FE
Pénznem:
2.52. példa: Számok kiíratása pénzösszegként, a pénznem megjelölésével
PS C:\> "{1,10:C}" -f 43.53,12.34
12,34 Ft
Vegyük észre, hogy itt szándékosan két értéket adtunk meg az ope-
rátor után, és ebből csak a másodikat jelenítettük meg! Ellenben, ha a
"{2,10:C}" -f 43.53,12.34 parancsot adjuk ki, az hibát jelezne, mivel
az argumentumlistában csak két érték van.
Az értékek pénznemként való formázásához a PowerShell az
operációs rendszer területi beállításait veszi figyelembe. Ha a vezér-
lőpulton átállítjuk a pénznemet, a PowerShell is ennek megfelelően
fogja formázni a számot:
2.53. példa: Számok kiíratása pénzösszegként, a pénznem megjelölésével, a területi
beállítás módosítása után
PS C:\> "{1,10:c}" -f 43.53,12.34
$12,34
Százalék:
2.54. példa: Számok kiíratása százalékos értékként
PS C:\> "{0:p}" -f 0.875, 0.790
87.50 %
65
Itt az előző példához hasonlóan két értéket adtunk meg, de abból

csak az elsőt írattuk ki.
Dátum és idő:
2.55. példa: Dátum- és időértékek formázása; a pontos idő kiíratása az aktuális időt
és dátumot tartalmazó objektumból
PS C:\> "{0:HH}:{0:mm}" -f (Get-Date)
17:32
A paraméterként megadott dátum típusú objektumból csak az órát

és a percet írjuk ki, kettősponttal elválasztva. A kapcsos zárójelek
közötti kettőspont után az alábbi, dátummal és idővel kapcsolatos
betűket használhatjuk:
Formázó Magyarázat
yy Az évszám utolsó két jegye (pl. 2007-ben 07)
yyyy Évszám négy számjeggyel
MM Hónap, számjegyekkel
MMM Hónap, rövidítve
MMMM Hónap, teljesen, betűkkel kiírva
dd Nap, számjegyekkel
ddd A hét napja, rövidítve
dddd A hét napja, teljesen, betűkkel kiírva
hh Óra (12 órás formátumban)
HH Óra (24 órás formátumban)
mm Perc
ss Másodperc
tt Napszak jelölése (területi beállítástól függően de./du., AM/PM stb.)
66
A teljes dátumot az alábbi parancs segítségével kapjuk vissza:

2.56. példa: A teljes dátum és idő kiíratása az aktuális dátumot és időt tartalmazó
objektumból
PS C:\> "{0:yyyy}. {0:MMMM} {0:dd} {0:hh}:{0:mm}:{0:ss} {0:tt},
{0:dddd}" -f (Get-Date)
2007. december 06 05:46:38 du., csütörtök
A Get-Date parancselemet azért szükséges zárójelek közé tenni, mert

a PowerShell különben nem tudná értelmezni. Annak hatására, hogy
zárójelek közé írtuk, először kiértékeli a parancsot (értsd: lekérdezi a
rendszeridőt), majd átadja a DateTime típusú objektumot az -f operá-
tornak. Amíg a parancs nincs kiértékelve, nem ad vissza értéket, így
nem is tudunk vele dolgozni. Ezt azzal is helyettesíthettük volna,
hogy először a Get-Date értékét egy változóba írjuk, majd a változót
adjuk meg az -f operátornak.
Lebegőpontos számok:
2.57. példa: Lebegőpontos számok (most épp a ) kiíratása adott pontossággal
PS C:\> "{0:f4}" -f [System.Math]::Pi
3.1416
Ha a {0:f4} helyett a {0:f3} formátumot írjuk, akkor négy tizedes jegy

helyett csak hármat jelenít meg a rendszer, természetesen megfelelő-
en kerekítve:
2.58. példa: Lebegőpontos számok (most épp a ) kiíratása 3 tizedesjegyre kerekítve
PS C:\> "{0:f3}" -f [System.Math]::Pi
3.142
67
HARMADIK FEJEZET
A rendszerfelügyelet alapjai
a PowerShellben
3.1. A függvények
A PowerShellben a gyakran ismétlődő vagy összetett feladatokból
függvényeket alakíthatunk ki. Ez egyszerűsíti a szkripteket, és meg-
könnyíti a a rendszer karbantartását.
3.1. példa: Függvény létrehozása és érték visszaadása
function returnValue($ertek) { return $ertek }
Ez a lehető legegyszerűbb függvény: mindössze visszaadja az argu-

mentumban megadott változó tartalmát. Túl sok haszna nincs, kizá-
rólag demonstrációs célból használjuk. A function kulcsszó után meg
kell adni a függvény nevét, majd zárójelben az argumentumokat –
egy vagy több változónevet – a függvényben ezekből a változókból
hívhatjuk elő a függvénynek argumentumként átadott adatokat. Ezt
követi kapcsos zárójelek között az a parancssorozat, amelyet a függ-
vénynek el kell végeznie. Ebben a függvényben csak az történik,
hogy a függvény visszatér azzal az értékkel, amelyet argumentum-
ként átadtunk (return parancsszó).
A következő példa egy olyan függvényt mutat be, amely a meg-
adott karakterláncból eltávolítja a szóközöket:
3.2. példa: Függvény, amely eltávolítja a szóközöket egy karakterláncból
function removeSpaces($str) { return $str.Replace(” ”,””) }
3.1. A függvények
Próbáljuk is ki:
3.3. példa: A szóközöket eltávolító függvény kipróbálása
PS C:\> removeSpaces("Ez itt a szöveg")
Ezittaszöveg
A függvények által visszaadott értékeket természetesen ugyanúgy

használhatjuk, mint a PowerShell beépített parancsainak kimenetét.
A (removeSpaces("Ez itt a szöveg")).Length utasítás tehát egy karakter-
lánc típusú objektum hosszát adja vissza.
Az alábbi függvény megcseréli egy IP-cím négy bájtját:
3.4. példa: Függvény, amely megfordítja a bájtokat egy IP-címben
PS C:\> function swapIP($ip) { $array=$ip.Split("."); $swapped="";
for ($i=$array.Length-1;$i -ge 0;$i--) { $swapped+=$array[$i]+"."
} $swapped=$swapped.Substring(0,$swapped.Length-1); return
$swapped }
PS C:\> swapIP("100.150.200.250")
250.200.150.100
A fenti függvény hívásakor az argumentumban megadott IP-cím az

$ip változóban van. Ennek meghívjuk a Split metódusát, amely a zá-
rójelben megadott karakterek mentén (itt a pont (.) karakter) szét-
vágja a karakterláncot és egy karakterláncokból álló tömbbe ( $array)
írja. Ezután létrehozzuk a $swapped változót, és üres karakterláncot
adunk neki értékül – biztos, ami biztos.
A függvény lényege a for ciklus, amely hátulról előre végigmegy
a tömbön, és összefűzi az elemeit a $swapped változóban. A for cik-
lus kezdőértéke a $array tömb mérete (mínusz egy, mivel a tömb első
elemének indexe 0, ezért az n-edik elem indexe n-1). A ciklust addig
ismételjük, amíg $i értéke nagyobb vagy egyenlő nullával, és mindig,
amikor lefutott a ciklus, $i-ből levonunk egyet. A for után lévő kap-
csos zárójelek között – a ciklus m a g j á b a n – a $swapped változó
végéhez hozzáfűzzük az $array tömb $i-edik elemét, majd a végére
teszünk egy pontot (mivel az $ip.Split(".") parancs a karakterláncból
eltávolította a pontokat).
70
3. fejezet: A rendszerfelügyelet alapjai a PowerShellben
Amikor a for ciklus véget ér, a $swapped változó értéke 250.200.

150.100., vagyis a megfordított IP-cím végén is volt pont. Ezt a
Substring metódussal eltüntetjük, majd a végén a függvény visszaad-
ja a $swapped változó értékét. A kapcsos zárójelek között az egy sor-
ban lévő, de különálló parancsokat pontosvesszővel választjuk el
egymástól.
Bár a fenti függvény nagyon jól működik, mégis elég átláthatat-
lan. A PowerShell lehetővé teszi, hogy egy egybefüggő utasítássoro-
zatot több sorban írjuk be; ennek feltétele, hogy valamilyen módon
jelezzük a PowerShellnek, hogy a parancs még nem ért véget. Ezt
egy megkezdett, de az első sor végén le nem zárt kapcsos zárójellel,
vagy a „|” (cső, pipe) karakterrel tehetjük meg. Talán a legegysze-
rűbb, ha a függvényt a jegyzettömbben (Notepad) írjuk meg:
3.5. példa: Függvény, amely megfordítja egy IP-cím bájtjait – szövegszerkesztőben
megírva
function swapIP($ip) {
$array=$ip.Split(".")
$swapped=""
for ($i=$array.Length-1;$i -ge 0;$i--) {
$swapped+=$array[$i]+"." }
$swapped=$swapped.Substring(0,$swapped.Length-1)
return $swapped
}
A jegyzettömbből illesszük be a kódot a PowerShellbe! Ezt ugyanúgy

tehetjük meg, mint a Windows-parancssorban. Kattintsunk a Power-
Shell-ablak bal felső sarkában az alkalmazásikonra, lépjünk az Edit
(Szerkesztés) parancsra, és az almenüből válasszuk a Paste (Beillesz-
tés) parancsot!
3.6. példa: Függvény kódjának beillesztése a PowerShellbe

PS C:\> function swapIP($ip) {
>> $array=$ip.Split(".")
>> $swapped=""
71
3.2. Folyamatok kezelése

>> for ($i=$array.Length-1;$i -ge 0;$i--) {
$swapped+=$array[$i]+"." }
>> $swapped=$swapped.Substring(0,$swapped.Length-1)
>> return $swapped
>> }
>>
Vegyük észre, hogy

1. a PowerShell a >> karakterekkel jelzi, hogy a parancs további so-
raira vár;
2. amikor az utasításblokkhoz valamennyi sort beírtuk, egy üres
sorban még le kell nyomnunk az ENTER billentyűt, ezzel jelezve,
hogy vége a blokknak;
3. a sorokra bontott függvényleírásban az egyes utasításokat nem
szükséges pontosvesszővel elválasztani.

Rendszergazdaként az egyik alapvető feladatunk a futó programok
folyamatainak kezelése. A PowerShellben erre a Get-Process és a
Stop-Process parancselemek állnak rendelkezésünkre. Ha paraméter
nélkül futtatjuk a Get-Process parancsot, visszakapjuk az összes, ép-
pen futó folyamat listáját:
3.7. példa: A folyamatok listájának kiíratása

PS C:\> Get-Process
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
27 1 372 1320 11 1876 AEADISRV
113 4 11688 9876 44 1148 audiodg
1675 41 42404 24404 237 114.36 4060 communicator
...
(A helykímélés végett a többi folyamatot kivágtuk.)
72
A Get-Process parancselem által visszaadott adatok is speciális ob-

jektumok (a jelen esetben System.Diagnostics.Process típusúak), tehát
ezek is rendelkeznek különböző metódusokkal és tulajdonságokkal.
Ha a Get-Process kimenetét továbbadjuk a Get-Member parancselem-
nek, megnézhetjük, melyek ezek. Az alábbiakban felsorolunk néhány
fontosabb tulajdonságot:
Tulajdonság Leírás
HasExited Boole típusú (logikai: igaz-hamis); igaz (true) az értéke, ha a
folyamat már befejezte a futást és kilépett
Id A folyamat azonosítója
PagedMemorySize A folyamat által lefoglalt olyan memóriaterületek méretének
összege, melyek igény esetén a memóriából kilapozhatók
(bájtban)
ProcessName A folyamat neve
Responding Boole (logikai) típusú; hamis (false) az értéke, ha a folyamat
nem válaszol
StartTime DateTime típusú; a folyamat elindításának időpontja
TotalProcessorTime TimeSpan típusú; a folyamat indítása óta eltelt, futással töl-
tött idő (vagyis az az időtartam, amit a processzor az adott
folyamat feldolgozásával eltöltött — ebben nincs benne a vá-
rakozással eltöltött idő)
WorkingSet A folyamat fizikai memóriahasználata (bájtban)
A felsorolt tulajdonságok segítségével például megkereshetjük azo-

kat a folyamatokat, amelyek a fizikai memóriából 50 MB-nál többet
használnak (méret szerint csökkenő sorrendben):
3.8. példa: Az 50 MB-nál több memóriát használó folyamatok kilistázása
PS C:\> Get-Process | Where-Object { $_.WorkingSet -gt 50MB } |
Sort-Object WorkingSet -Descending

------- ------ ----- ----- ----- ------ -- -----------
4135 54 79660 121296 401 21.04 2984 OUTLOOK
73

179 8 42816 84952 169 217.87 4008 dwm
1109 32 34220 67100 332 158.61 4912 WINWORD
931 20 65816 66168 178 1068 svchost
1058 35 53052 60288 312 68.53 3160 explorer
872 26 62052 57816 230 39.17 464 iexplore
Ha úgy döntünk, leállíthatjuk a legtöbb memóriát használó folyama-

tot:
3.9. példa: A legtöbb memóriát használó folyamat leállítása
PS C:\> Get-Process | Where-Object { $_.WorkingSet -gt 80MB } |
Sort-Object WorkingSet -Descending

------- ------ ----- ----- ----- ------ -- -----------
4056 53 77904 124536 397 21.22 2984 OUTLOOK
179 8 42824 89764 174 218.54 4008 dwm
PS C:\> Get-Process | Sort-Object WorkingSet -Descending | Select

-First 1 | Stop-Process
PS C:\> Get-Process | Where-Object { $_.WorkingSet -gt 80MB } | Sort-
Object WorkingSet –Descending

------- ------ ----- ----- ----- ------ -- -----------
179 8 42824 89764 174 218.54 4008 dwm
A példa kedvéért itt először ellenőrizzük, mely folyamatok használ-

nak 80 MB-nál több memóriát, utána leállítjuk a legnagyobbat. Ez-
után meggyőződünk arról, hogy tényleg leállt: ismét megnézzük a 80
MB-nál több memóriát fogyasztó programok listáját.
A folyamat leállításának sikeréről úgy is megbizonyosodhatunk,
hogy a legtöbb memóriát használó folyamat objektumát változóba
helyezzük, leállítjuk, majd megvizsgáljuk a HasExited tulajdonságát:
74
3.10. példa: Folyamat sikeres leállításának ellenőrzése

PS C:\> $sokmemoria = Get-Process | Sort-Object WorkingSet -
Descending | Select -First 1
PS C:\> $sokmemoria

------- ------ ----- ----- ----- ------ -- -----------
3794 47 56624 100320 399 25.38 3852 OUTLOOK
PS C:\> $sokmemoria.HasExited
False
PS C:\> $sokmemoria | Stop-Process
PS C:\> $sokmemoria.HasExited
True
Megjegyzés: a Process típusú objektumok rendelkeznek egy Kill() me-

tódussal is. A fenti példában a $sokmemoria | Stop-Process helyett
$sokmemoria.Kill()-t is írhattunk volna. Ugyanaz lett volna az ered-
mény: a folyamatot a Windows azonnal leállítja, és az el nem mentett
adatok elvesznek.
Megkereshetjük az összes olyan folyamatot is, amely épp nem vá-
laszol:
3.11. példa: A nem válaszoló folyamatok megkeresése
PS C:\> Get-Process | Where-Object { -not $_.Responding }

------- ------ ----- ----- ----- ------ -- -----------
49 3 1528 5732 59 6.74 3472 calc
A fenti minta alapján a nem válaszoló folyamatokat is leállíthatjuk a

Get-Process | Where-Object { -not $_.Responding } | Stop-Process pa-
ranccsal.
75
3.3. Dátum és idő

Mint ismeretes, az informatikai rendszerekben rendkívül fontos az
idő. Tudnunk kell, hogy egy-egy fájlhoz mikor fértek utoljára hozzá,
mikor módosították, mikor jött létre egy mappa, mikor történt egy
adott esemény (például a számítógépre történő bejelentkezés vagy
egy merevlemezhiba). Így tehát nem meglepő, hogy a dátum és az
idő kezelésére a .NET-keretrendszerben (így a PowerShellben is) kü-
lön típust használhatunk.
A második fejezetben említettük a Get-Date parancselemet. Most
ismerkedjünk meg vele közelebbről! Ha önmagában lefuttatjuk, visz-
szaadja az aktuális rendszeridőt, de ha a kimenetét átküldjük a Get-
Member parancselemnek, láthatjuk, hogy ennél jóval többre képes.
Ha például meghívjuk a DateTime típusú érték AddDays metódusát,
az aktuális dátumhoz hozzáadhatunk tetszőleges számú napot:
3.12. példa: Az aktuális dátum változóba helyezése, egy nap hozzáadása
PS C:\> $a=Get-Date
PS C:\> $a
2008. július 7. 21:52:18
PS C:\> $a.AddDays(1)
2008. július 8. 21:52:18
A fenti példát változó közbeiktatása nélkül is megoldhatjuk:

3.13. példa: Egy nap hozzáadása az aktuális dátumhoz
PS C:\> (Get-Date).AddDays(1)
2008. július 8. 21:56:55
Itt azért kellett a parancssort zárójelbe írni, mert így érhetjük el, hogy
a PowerShell először a Get-Date parancsot hajtsa végre, és a vissza-
adott DateTime típusú objektum AddDays metódusát hívja meg. El-
76
lenkező esetben a paranccsor a Get-Date objektum AddDays metódusát

próbálná meg végrehajtani, viszont a Get-Date nem DateTime típusú.
A DateTime típusnak az AddDays-en kívül van AddTicks, AddMilli-
Seconds, AddSeconds, AddMinutes, AddHours, AddMonths és AddYears
metódusa is, ezekkel rendre óraütéseket, ezredmásodperceket, másod-
perceket, perceket, órákat, hónapokat, illetve éveket adhatunk egy
időponthoz. Ó r a ü t é s n e k (tick) a Windowsban létező legkisebb
időegységét nevezzük. Egy másodperc 10 000 000 óraütésből áll.
Most már bonyolultabb feladatra is vállalkozhatunk: keressük
meg az aktuális mappában azokat az objektumokat, amelyeket már
legalább két hete nem használtak:
3.14. példa: A legalább két hete nem használt objektumok megkeresése az aktuális
mappában
PS C:\> Get-ChildItem | Where-Object { $_.LastAccessTime -lt (Get-
Date).AddDays(-14) }

---- ------------- ------ ----
d---- 2008.06.22. 2:53 MSDN
d---- 2007.09.29. 15:28 symbols
d-r-- 2007.12.07. 11:05 Users
d---- 2008.06.13. 21:49 Windows
-a--- 2006.09.18. 23:43 24 autoexec.bat
-a--- 2006.09.18. 23:43 10 config.sys
A fenti példában megszűrjük a Get-ChildItem parancselem kimenetét,

hogy csak azokat az elemek maradjanak benne amelyek LastAccess-
Time tulajdonsága kisebb, mint az aktuális dátum mínusz 14 nap. Ha
elég bátrak és elszántak vagyunk, ennek a parancsnak a kimenetét
továbbküldhetjük a Remove-Item parancselemnek, így letörölhetjük
azokat a fájlokat, melyeket egy ideje már nem használtunk.
Fontos! Ha gyakorlunk, ezt ne a C: meghajtó gyökérmappájában
és ne is a Dokumentumok mappánkban tegyük, hanem egy ideiglenes
77
(Temp) mappában, vagy egyéb olyan helyen, ahol ezzel nem okozha-
tunk kárt.
Ha két DateTime típusú objektumot kivonunk egymásból, egy
TimeSpan (időtartam) típusú objektumot kapunk eredményül, amely-
nek szintén érdekes tulajdonságai vannak:
3.15. példa: Dátumok kivonása, időtartam kiszámítása
PS C:\> $a = Get-Date
PS C:\> $b = Get-Date "2008.01.01 0:00"
PS C:\> $a-$b
Days : 188
Hours : 22
Minutes : 33
Seconds : 7
Milliseconds : 888
Ticks : 163243878881532
TotalDays : 188.939674631403
TotalHours : 4534.55219115367
TotalMinutes : 272073.13146922
TotalSeconds : 16324387.8881532
TotalMilliseconds : 16324387888.1532
A Days, Hours, Minutes, Seconds és Milliseconds tulajdonságok azt mu-

tatják meg, hogy a két időpont között hány nap, óra, perc, másod-
perc és ezredmásodperc telt el. A TotalDays, TotalHours, TotalMinutes,
TotalSeconds és TotalMilliseconds tulajdonságok azt jelzik, hogy ösz-
szesen mennyi ez az időtartam napban, órában, percben, másod-
percben, illetve ezredmásodpercben kifejezve.
78
3.4. Az eseménynapló
A Windows az eseménynaplón keresztül kommunikál a rendszer-
gazdával, ide írja a fontos és kevésbé fontos rendszereseményeket,
amelyeket három fő tárolóban helyez el. Az Alkalmazás (Application)
naplóban a különböző (általunk, illetve a Windowszal együtt telepí-
tett) programok üzeneteit láthatjuk. A Biztonság (Security) napló a
rendszer biztonságát érintő eseményeket (bejelentkezés, jogosultsá-
gok módosítása stb.) rögzíti. Ha a fájlok és objektumok naplózását
engedélyezzük, annak eseményeit is itt láthatjuk. A Rendszernapló
(System) pedig az operációs rendszer, illetve a hardver működésével
kapcsolatos eseményeket tartalmazza. Az egyes naplók rengeteg,
akár több százezer eseményt tartalmazhatnak, így hasznosnak bizo-
nyul, ha tudunk bennük keresni.
Ebben a Get-EventLog parancselem nyújt segítséget, amelynek pa-
ramétereként meg kell adnunk, hogy mely napló bejegyzéseire van
szükségünk. A Rendszernapló összes eseményét például a Get-
EventLog System parancs jeleníti meg. Ez nem segít rajtunk, mert ol-
dalakon keresztül sorolja a lényegtelen eseményeket. Ha megadjuk a
–Newest paramétert, ez történik:
3.16. példa: A rendszernaplóban levő 10 legújabb esemény kiíratása

PS C:\> Get-EventLog System -Newest 10
Index Time Type Source EventID Message

----- ---- ---- ------ ------- -------
86248 júl. 07 22:54 Erro Dhcp 1001 Your computer...
86245 júl. 07 22:39 Info Microsoft-Windows... 1500 The Group Pol...
86244 júl. 07 22:39 Info Microsoft-Windows... 1501 The Group Pol...
86239 júl. 07 22:13 Info Service Control M... 7036 The descripti...
79
3.4. Az eseménynapló
Így csak a legutolsó 10 bejegyzést jeleníti meg a rendszer, ami egy

fokkal emészthetőbb, de még mindig nem ad elég információt. Ke-
ressük most meg a lemezalrendszer üzeneteit:
3.17. példa: A lemezalrendszer (Disk forrás) eseményeinek kiíratása a
rendszernaplóból
PS C:\> Get-EventLog System | Where-Object { $_.Source -eq "Disk" }

----- ---- ---- ------ ------- -------
85735 jún. 29 09:42 Warn disk 51 An error was...
85734 jún. 29 09:42 Warn disk 51 An error was...
Látható, hogy a rendszernaplóba június 29-ei dátummal két, lemez-

zel kapcsolatos figyelmeztetés került.
Szűrésünket akár finomíthatjuk is: keressünk olyan, a W32Time
forrásból származó információ típusú1 eseményeket, amelyek az el-
múlt 24 órában kerültek a naplóba:
3.18. példa: Adott forrásból származó, a rendszernaplóba az elmúlt 24 órában beírt
események megkeresése
PS C:\> Get-EventLog System | Where-Object { $_.Source -eq
"W32Time" -and $_.TimeGenerated -gt (Get-Date).AddDays(-1) -and
$_.EntryType -eq "Information" }

----- ---- ---- ------ ------- -------
86236 júl. 07 22:05 Info W32Time 35 The time serv...
86235 júl. 07 22:05 Info W32Time 37 The time prov...
1 Az alkalmazásba és a rendszernaplóba általában háromféle esemény ke-

rül: h i b a (error), f i g y e l m e z t e t é s (warning) és i n f o r m á c i ó (in-
formation). Van még két eseménytípus: a s i k e r (success) és a s i k e r t e -
l e n s é g (failure), amelyeket elsősorban a biztonsági rendszer használ,
hogy jelezze: elutasította vagy engedélyezte egy művelet végrehajtását.
80
Megjegyzés: a Source, TimeGenerated és EntryType tulajdonságokat a

Get-EventLog | Get-Member parancsból tudjuk.
Ha egy bizonyos típusú eseményből csak az utolsó néhány pél-
dány érdekes, azokat ne a Get-EventLog parancselem -Newest para-
méterével próbáljuk meg kiszűrni, mert ilyenkor az előző parancs
kimenetéből már csak a néhány legutolsó esemény megy tovább,
nem pedig a számunkra fontosak. Ilyen esetben inkább fűzzük a cső
végére, a Where-Object után a Select-Object parancselemet:
3.19. példa: Adott forrásból származó, legfeljebb 3, legfeljebb 1 napos esemény kiírása
PS C:\> Get-EventLog System | Where-Object { $_.Source -eq "W32Time" -
and $_.TimeGenerated -gt (Get-Date).AddDays(-1) -and $_.EntryType -eq
"Information" } | Select-Object -First 3

----- ---- ---- ------ ------- -------
86236 júl. 07 22:05 Info W32Time 35 The time serv...
3.5. Szkriptek futtatása fájlból

Már sok mindent meg tudunk oldani a PowerShellben, de a mun-
kánk nem hatékony, ha a parancsokat minden egyes alkalommal be
kell gépelnünk. Megtehetjük, hogy a parancskötegekhez vagy a
VBScript-fájlokhoz hasonlóan a PowerShell-parancsokat is szöveges
fájlba írjuk, majd onnan futtatjuk őket. Ehhez elvileg nem kell mást
tennünk, mint megírni a szkriptet a jegyzettömbben (Notepad), majd
elmenteni egy .ps1 kiterjesztésű fájlba.
Ha azonban ezt a fájlt megpróbáljuk elindítani egy PowerShell-
ablakból, kapunk egy hibaüzenetet: File fájlnév cannot be loaded be-
cause the execution of scripts is disabled on this system. Ennek bizton-
sági oka van: már a PowerShell (korábbi nevén Monad Shell) fejlesz-
81
tésekor nagy port kavart az hír, hogy a még meg sem jelent parancs-
héjra megírták az első férget.
Ez azt jelentette, hogy ha a felhasználó megkapta a rosszindulatú
szkriptet, és szándékosan elindította, akkor az fájlmásolási művele-
tekkel „megfertőzte” a gépet. Ezt túlzás féregnek vagy vírusnak ne-
vezni, mivel szándékos felhasználói beavatkozás szükséges a „fertő-
zéshez”, viszont a bulvárhír elterjedéséhez ennyi már elég volt.
Azóta a PowerShellbe több, biztonságot növelő megoldást is be-
építettek. Ezek közé tartozik az is, hogy ha egy PowerShell parancs-
sorba beírjuk egy .ps1 fájl nevét, az alapértelmezés nem indul el.
Futtatási házirend
Az előbbiekben vázolt viselkedést a futtatási házirend módosításával

szabályozhatjuk, amelyet a Set-ExecutionPolicy parancselemmel érhe-
tünk el. A parancs egyetlen, -ExecutionPolicy nevű argumentummal
rendelkezik, amellyel a házirendet vezérelhetjük. Ez az alábbi para-
métereket ismeri:
Paraméter Leírás
Unrestricted Bármilyen szkript korlátozás nélkül futhat a rendszeren.
RemoteSigned Az internetről letöltött szkripteket el kell látni egy megbízható fél
által kiállított digitális aláírással; a helyi szkriptek korlátozás nélkül
futnak.
AllSigned Minden szkriptnek digitális aláírással kell rendelkeznie.
Restricted Semmilyen szkript vagy konfigurációs fájl nem futhat.
Default Az alapértelmezett beállítás a Restricted, akár ezt, akár a Default
beállítást adjuk meg, az eredmény ugyanaz.
Megjegyzés: a feladat végrehajtásához rendszergazdai jogosultsá-

gokra lesz szükségünk, ezért Windows Vistán vagy annál újabb ope-
82
rációs rendszereken a PowerShellt a Futtatás rendszergazdaként (Run

As Administrator) beállítással indítsuk.
Amíg tanuljuk a PowerShell használatát, az egyszerűség kedvéért
a futtatási házirendet a Set-ExecutionPolicy –ExecutionPolicy Unrest-
ricted paranccsal állítsuk az Unrestricted értékre, de vigyázzunk, éles
környezetben ez potenciális biztonsági kockázatot jelent! Ha aggó-
dunk az internetről letöltött szkriptek miatt, az Unrestricted helyett
használhatjuk a RemoteSigned beállítást.
Digitális aláírás
A szkriptek aláírásához szükséges tanúsítványokra több helyről is

szert tehetünk. Megvásárolhatjuk hivatalos hitelesítésszolgáltatótól,
de ez igen sokba kerül, és legtöbbször nincs is rá szükségünk. Ha ez
nem felel meg, kiszolgálóoldali operációs rendszeren magunk is te-
lepíthetjük a Microsoft Certification Authority (tanúsítvány-, illetve
hitelesítésszolgáltató) szolgáltatást, és ezzel kiállíthatunk a magunk
számára olyan tanúsítványt, amely megfelel a célnak. Ha a Microsoft
CA-t még nem telepítettük, és nem akarunk ezzel bajlódni, lehetősé-
günk van úgynevezett ö n a l á í r t t a n ú s í t v á n y létrehozására
is, amelyet nem hitelesítésszolgáltató ad ki, hanem mi hozzuk létre
saját magunknak. Kisebb környezetben, illetve tesztelés céljából ez
tökéletesen megfelel, de egy nagyobb hálózaton célszerűbb hitelesí-
tésszolgálatót telepíteni.
Önaláírt tanúsítványt számos módon létrehozhatunk. Erre szolgál
a .NET Framework 2.0 SDK-ban (Software Development Kit, szoft-
verfejlesztői csomag) lévő MakeCert.exe program is. Próbáljuk ki! A
Microsoft honlapján keressünk rá a .NET 2.0 SDK kifejezésre, majd
töltsük le és telepítsük a csomagot. Ha a telepítés véget ért, lépjünk
be a program mappájába, majd az alábbi paranccsal hozzuk létre a
kívánt tanúsítványt a saját tanúsítványtárunkban:
83
3.20. példa: Gyökértanúsítvány, majd PowerShell-szkriptek futtatásához szükséges

tanúsítvány létrehozása
C:\>makecert -n "CN=PowerShell Local Certificate Root" -a sha1 -
eku 1.3.6.1.5.5.7.3.3 -r -sv root.pvk root.cer -ss Root
Succeeded
C:\>makecert -pe -n "CN=PowerShell User" -ss MY -a sha1 -eku

1.3.6.1.5.5.7.3.3 -iv root.pvk -ic root.cer
Succeeded
Az első parancs jelszót kér (háromszor), amely létrehozza és telepíti

a helyi tanúsítványszolgáltató gyökértanúsítványát. A második pa-
rancs ismét kéri az első parancs során megadott jelszót, majd létre-
hoz és az első parancsban generált tanúsítvánnyal aláír egy felhasz-
nálói tanúsítványt.
Az elmúlt évek, lassan évtizedek alatt megszokhattuk, hogy a
Windows-világban a lemezeken található egyes köteteket betűkkel
jelöljük. A meghajtó:\mappa\almappa\fájlnév.kiterjesztés elérési utakat
már mindannyian jól ismerjük. Ebből kiindulva a PowerShell fejlesz-
tői úgy döntöttek, hogy ilyen módon egyéb tárakat is elérhetővé
tesznek. A rendelkezésre álló meghajtók listáját a Get-PSDrive pa-
rancselemmel kérdezhetjük le; a listában megjelenik a Cert: meghajtó
is, amely az operációs rendszer tanúsítványtárát jelöli.
3.21. példa: A tanúsítványtár mint meghajtó kezelése
PS C:\> cd Cert:
PS cert:\> dir
Location : CurrentUser
StoreNames : {SmartCardRoot, UserDS, AuthRoot, CA...}
Location : LocalMachine
StoreNames : {SmartCardRoot, AuthRoot, CA, Trust...}
A példában az ismert parancsokra emlékeztető álneveket használtuk.

A cd parancsot valójában Set-Locationnek hívják, a dir becsületes ne-
ve pedig a már többször használt Get-ChildItem.
84
Keressük meg az előbbiekben létrehozott tanúsítványt:

3.22. példa: Tanúsítvány megkeresése a tanúsítványtárban
PS cert:\> Set-Location CurrentUser
PS cert:\CurrentUser> Set-Location My
PS cert:\CurrentUser\My> Get-ChildItem
Directory: Microsoft.PowerShell.Security\Certificate::CurrentUser\My
Thumbprint Subject
---------- -------
AF86CC088BDC6E71F8BBA77D36676A9D949C704F CN=PowerShell User
91288B901CCDC00F043546D39767D513F85D0FB3 CN=HOME\MartonSz
Láthatjuk, hogy példánkban a keresett tanúsítvány ujjlenyomata az

AF86 karakterekkel kezdődik. Ezt helyezzük el egy változóban, majd
állítsuk át a futtatási házirendet, hogy a rendszer csak a digitálisan
aláírt parancsfájlokat futtassa. Ezután próbáljuk ismét elindítani a
korábban létrehozott szkriptet. Először ez nem sikerül, mert a szkript
még nincs aláírva. Most írjuk alá a szkriptet a Set-AuthenticodeSigna-
ture parancselemmel, és futtassuk ismét:
3.23. példa: PowerShell-szkript aláírása tanúsítvánnyal

PS cert:\CurrentUser\My> $cert = Get-ChildItem
AF86CC088BDC6E71F8BBA77D36676A9D949C704F
PS cert:\CurrentUser\My> c:
PS C:\> Set-ExecutionPolicy -ExecutionPolicy AllSigned
PS C:\> .\test.ps1
File C:\test.ps1 cannot be loaded. The file C:\test.ps1 is not
digitally signed. The script will not execute on the system.
Please see "get-help about_signing" for more details..
At line:1 char:10
+ .\test.ps1 <<<<
PS C:\> Set-AuthenticodeSignature -Certificate $cert -FilePath
test.ps1
Directory: C:\
SignerCertificate Status
Path
----------------- ------
85

AF86CC088BDC6E71F8BBA77D36676A9D949C704F Valid
test.ps1
PS C:\> .\test.ps1
Do you want to run software from this untrusted publisher?

File C:\test.ps1 is published by CN=PowerShell User and is not
trusted on your system. Only run scripts from trusted publishers.
[V] Never run [D] Do not run [R] Run once [A] Always run [?]
Help (default is "D"): R
Ez egy próba szkript.
Kiírunk két sort.
Az így aláírt fájlok tartalmának sértetlenségét a PowerShell az aláírás

révén tudja garantálni. Ha az előbbi fájlban akár egy karaktert is
megváltoztatunk, hibaüzenetet kapunk, és a szkript nem fut le.
Végül a .ps1 kiterjesztésű fájlokhoz társítsuk a Windows mappa
System32\WindowsPowerShell\v1.0 almappájában található power-
shell.exe programot! Ha ezután elindítunk egy .ps1 kiterjesztésű fájlt,
azt a PowerShell értelmezi majd.
Ha a PowerShellt a Windows-tartományunk valamennyi munka-
állomására telepítjük, a b e j e l e n t k e z é s i p a r a n c s f á j l o k a t
(logon script) is megírhatjuk a PowerShellben.
86
NEGYEDIK FEJEZET
Fájlkezelés
A PowerShellt igyekeztek úgy kifejleszteni, hogy sokoldalú, mégis

egységes legyen. Ezt tükrözi a parancselemek ige-főnév felépítése, az
argumentumok egységesítése és a nem fájlokat tartalmazó tárolók
meghajtóként való megjelenítése is. Az előző fejezetben láttuk, hogy
a fájlrendszerhez hasonló módon kezelhetjük például a helyi tanú-
sítványtárat. Ebben a fejezetben látjuk majd, hogy a fájlrendszer be-
jegyzéseit, a fájlokat és a mappákat is ugyanúgy, ugyanazokkal a pa-
rancselemekkel kell kezelni.
4.1. Fájlok és mappák

A fájlokon és a mappákon jórészt az Item végű parancselemekkel vé-
gezhetünk műveleteket:
4.1. példa: Az -Item végű parancselemek kilistázása
PS C:\> Get-Help *-Item
Name Category Synopsis

---- -------- --------
Get-Item Cmdlet Gets the item at the specified location.
New-Item Cmdlet Creates a new item in a namespace.
Set-Item Cmdlet Changes the value of an item to the value specif...
Remove-Item Cmdlet Deletes the specified items.
Move-Item Cmdlet Moves an item from one location to another.
Rename-Item Cmdlet Renames an item in a Windows PowerShell provider...
Copy-Item Cmdlet Copies an item from one location to another with...
Clear-Item Cmdlet Deletes the contents of an item, but does not de...
Invoke-Item Cmdlet Invokes the provider-specific default action on ...
Az egyes parancselemek rendeltetése:
Parancselem Leírás
Get-Item Egy elem (pl. fájl vagy mappa) vagy tulajdonságainak lekérdezése
New-Item Új elem (fájl, mappa) létrehozása
Set-Item Egy elem értékének módosítása1
Remove-Item Egy vagy több elem eltávolítása (törlése)
Move-Item Egy elem áthelyezése
Rename-Item Elem átnevezése
Copy-Item Elemek másolása
Clear-Item Az elem tartalmának kiürítése1
Invoke-Item Elem meghívása – .doc kiterjesztésű fájlok meghívása például a
Word elindítását és a dokumentum megnyitását eredményezi
Tegyük fel, hogy a helyi hálózatban, egy megosztott mappán belül,

van egy ideiglenes mappa, amelyet a felhasználók átmeneti tároló-
ként használhatnak. Egy ilyen mappa gyorsan elég nagyra nőhet, így
nem árt időnként kitakarítani – de vigyázni kell, nehogy a tisztoga-
tásnak értékes adatok is áldozatul essenek. Írjunk olyan szkriptet,
amely minden nap végignézi a mappát, a .doc kiterjesztésű fájlokat
másik helyre mozgatja, a többi fájlt pedig letörli:
4.2. példa: A .doc kiterjesztésű fájlok áthelyezése, a többi fájl kitörlése adott mappából
Get-ChildItem -Path C:\Megosztott\Mappa -Recurse | ForEach-Object
{
if ($_.Extension -eq ".doc" ) {
Move-Item -Path $_.FullName -Destination C:\Masik\Mappa
} else {
Remove-Item -Path $_.FullName } }
Bővítsük tovább a fenti példát: a takarítás előtt a szkript hozzon létre

egy mappát, amelynek neve az aktuális dátum, és helyezze abba a
.doc-fájlokat.
1 A parancselem nem használható fájlokon és mappákon.
88
4. fejezet: Fájlkezelés
Mielőtt elkezdenénk módosítani a fenti szkriptet, először próbál-

juk ki egyes részeit! Kérdezzük le az aktuális dátumot, helyezzük
változóba, majd fűzzük össze az évet, a hónapot és a napot:
4.3. példa: Év, hónap és nap hibás összefűzése dátumban
PS C:\> $date=Get-Date
PS C:\> $date.Year + $date.Month + $date.Day
2024
Nem az történt, amit szerettünk volna: a PowerShell az évet, a hóna-

pot és a napot számként kezelte, és összeadta őket, a 2008-at, a 7-et,
és a 9-et (2008+7+9=2024). El kell érnünk, hogy ezek az értékek ne
számként, hanem szövegként jelenjenek meg. Ennek legegyszerűbb
módja, ha az egészet egy üres karakterlánchoz fűzzük hozzá:
4.4. példa: Év, hónap és nap majdnem helyes összefűzése dátumban
PS C:\> "" + $date.Year + $date.Month + $date.Day
200879
Ez már hasonlít arra, amire gondoltunk, de még mindig elég olvas-

hatatlan. Jobb lenne, ha a szkript a hónap (7-es) és a nap (9-es) elé
nullát írna, így: 20080709. Ha azonban feltétel nélkül beírjuk a nullát
is, november 22-e ilyen lenne: 2008011022. A feladat az, hogy a hó-
nap és a nap elé csak akkor írjunk nullát, ha az 10-nél kisebb:
4.5. példa: Év, hónap és nap helyes összefűzése dátumban
PS C:\> $hoNulla=""
PS C:\> $napNulla=""
PS C:\> if ($date.Month -lt 10) { $hoNulla="0"; }
PS C:\> if ($date.Day -lt 10) { $napNulla="0"; }
PS C:\> "" + $date.Year + $hoNulla + $date.Month + $napNulla +
$date.Day
20080709
Létrehozunk egy-egy változót, melyek kezdetben üres karakterlán-

cot tartalmaznak, majd megvizsgáljuk a hónap, illetve a nap számát,
89
és szükség szerint a megfelelő változó elejére „0”-t írunk. Ezután az

évszámhoz a két változó tartalmát írjuk hozzá.
Most írjuk hozzá az előző szkripthez a naponkénti szétválogatást:
4.6. példa: A .doc kiterjesztésű fájlok áthelyezése egy, az aktuális dátumról elnevezett
mappába
$hoNulla=""
$napNulla=""
if ($date.Month -lt 10) { $hoNulla="0"; }
if ($date.Day -lt 10) { $napNulla="0"; }
$mappa = "" + $date.Year + $hoNulla + $date.Month + $napNulla +
$date.Day
New-Item -Path C:\Masik\Mappa\$mappa -ItemType Directory
Get-ChildItem -Path C:\Megosztott\Mappa -Recurse | ForEach-Object
{
if ($_.Extension -eq ".doc" ) {
Move-Item -Path $_.FullName -Destination C:\Masik\Mappa\$mappa
} else {
Remove-Item -Path $_.FullName } }
Természetesen a fenti példában látott – a fájlok áthelyezésével meg-

egyező – módon áthelyezhetünk mappákat is. Ellenben a Copy-Item
parancselem – amelynek paraméterezése megegyezik a Move-Item
parancséval – nem úgy működik, ahogy azt elsőre várnánk. Ha map-
pát szeretnénk másolni annak tartalmával együtt, meg kell adnunk a
-Recurse kapcsolót is, különben a parancs csak létrehozza a -Path-ban
megadott mappát. A fájlok másolása máskülönben a szokásos mó-
don történik.
Az aktuális mappából a Set-Location parancselem segítségével
léphetünk más mappába. Ehhez kapcsolódik még a Push-Location és
a Pop-Location parancselem. A Push-Location elmenti egy átmeneti
tárba az épp aktuális elérési utat, majd ha onnan más tárolóba (map-
pába) lépünk, a Pop-Location parancselemmel egy lépésben vissza-
térhetünk az eredeti helyre:2
2 Ezek a parancsok léteznek a „hagyományos” Windows-parancssorban is.

A Push-Location neve ott pushd, a Pop-Location neve pedig popd.
90
4.7. példa: A Push-Location és a Pop-Location parancselemek használata

PS C:\Users\MartonSz\Desktop> Push-Location
PS C:\Users\MartonSz\Desktop> Set-Location
C:\Windows\Microsoft.NET\Framework\v2.0.50727
PS C:\Windows\Microsoft.NET\Framework\v2.0.50727> Pop-Location
PS C:\Users\MartonSz\Desktop>
4.2. Fájlok tartalmának beolvasása
Amikor ismétlődő feladatokat automatizálunk, szükségünk lehet ar-

ra, hogy adatokat olvassunk fájlokból. Írhatunk például egyszerű (de
annál nagyszerűbb) letöltéskezelőt: beírjuk egy fájlba a letöltendő fáj-
lok címét, majd a címeket soronként kiolvasva letöltjük a korábban
már említett, ingyenes wget.exe programmal.
4.8. példa: Fájlok letöltése szövegfájlban felsorolt URL-címekről
Get-Content download.txt | ForEach-Object { wget.exe $_ }
A Get-Content parancselem egy karakterlánc típusú gyűjteményben

visszaadja a download.txt fájl tartalmát. A gyűjteményben levő ka-
rakterláncok egy-egy fájlbéli sornak felelnek meg. Így, ha a
download.txt fájl minden sorába egy-egy letöltendő fájl URL-címét ír-
juk, a példabeli ForEach-Object parancs egyenként letölti a fájlokat a
wget programmal.
Ami itt következik, nem teljesen szabályos. A PowerShellben az
aláírási követelményeket megkerülve is futtathatunk szkripteket.
Amikor a PowerShell fájlból futtat szkriptet, soronként beolvassa a
fájl tartalmát, és egyenként lefuttat minden sort. Erre magunk is írha-
tunk parancsot: az Invoke-Expression parancselem az argumentum-
ban megadott karakterláncot PowerShell-parancsként értelmezi és
futtatja, pontosan úgy, mintha begépeltük volna:
4.9. példa: Karakterláncban tárolt parancs futtatása
PS C:\Users\MartonSz\Desktop> Invoke-Expression "Set-Location C:\"
PS C:\>
91
A parancsot a parancselem változóból is kaphatja:

4.10. példa: Változóban tárolt parancs futtatása
PS C:\> $parancs = "Get-ChildItem"
PS C:\> $parancs
Get-ChildItem
PS C:\> Invoke-Expression $parancs

---- ------------- ------ ----
d---- 2008.07.11. 20:39 inetpub
d---- 2008.06.22. 2:53 MSDN
d-r-- 2008.07.15. 22:21 Program Files
...
Ha pedig a lefuttatandó sorok fájlban vannak, a fájl tartalmát így kell

lefuttatni (vigyázat, csak olyan fájlt futtassunk így, amelynek ponto-
san ismerjük a tartalmát!):
4.11. példa: Szövegfájl soraiban tárolt parancsok futtatása
Get-Content download.txt | ForEach-Object { Invoke-Expression $_ }
A Get-Content parancselem soronként – és szövegként – olvassa be a

fájlok tartalmát. Az Import-Csv parancselem ezzel szemben vesszővel
(vagy a magyar területi beállítások esetén pontosvesszővel) tagolt
fájlok beolvasására alkalmas. A fájlban levő értékeket gyűjtemény-
ként – nem feltétlenül szövegként – adja vissza. Hozzunk létre egy
emberek.csv nevű fájlt, amelynek tartalma legyen a következő:
Nev,Szuletesnap
Bekre Pál,1956.04.23
Minden Áron,1961.08.15
Kalim Pál,1974.02.06
Feltét Elek,1963.10.14
92
A .csv fájlt ezután olvassuk be az Import-Csv parancselemmel:

4.12. példa: CSV-fájl beolvasása objektumgyűjteménybe
PS C:\> Import-Csv emberek.csv
Nev Szuletesnap
--- -----------
Bekre Pál 1956.04.23
Minden Áron 1961.08.15
Kalim Pál 1974.02.06
Feltét Elek 1963.10.14
PS C:\> Import-Csv emberek.csv | Get-Member
TypeName: System.Management.Automation.PSCustomObject
Name MemberType Definition

---- ---------- ----------
Equals Method System.Boolean Equals(Object obj)
GetHashCode Method System.Int32 GetHashCode()
GetType Method System.Type GetType()
ToString Method System.String ToString()
Nev NoteProperty System.String Nev=Bekre Pál
Szuletesnap NoteProperty System.String Szuletesnap=1956.04.23
Látható, hogy a .csv fájl első sora fejléc, vagyis a két oszlopnak a Nev
és a Szuletesnap neveket adtuk. Ezután e nevekkel hivatkozhatunk
az adott oszlopban található adatokra. Nézzük meg, hogy a Pál ke-
resztnevű emberek mikor születtek, avagy PowerShellül: soroljuk fel
a gyűjteményből azokat az elemeket, ahol a Nev tulajdonságban
megtalálható a „Pál” karakterlánc:
4.13. példa: Meghatározott nevű objektumok beolvasása CSV-fájlból
PS C:\> Import-Csv emberek.csv | Where-Object { $_.Nev -match
"Pál" }
Nev Szuletesnap
--- -----------
Bekre Pál 1956.04.23
Kalim Pál 1974.02.06
93
4.3. A fájlokhoz és mappákhoz tartozó engedélyek
A .csv fájlokat nemcsak importálni lehet. Az Export-Csv parancselem

a megadott fájlba vesszővel (magyar területi beállítás esetén pontos-
vesszővel) elválasztva beleírja a parancs bemenetén megadott (a cső-
ben érkező) gyűjtemény tartalmát, például: Get-ChildItem | Export-
Csv fajlok.csv.
4.3. A fájlokhoz és mappákhoz

tartozó engedélyek
Gyakori feladat a különböző fájlrendszer-objektumokhoz – fájlokhoz
és mappákhoz – tartozó engedélyek módosítása. Ez a PowerShellben
nem tartozik a legegyszerűbb feladatok közé, ezért nem tudjuk a ma-
ga teljességében megmutatni. Egy-egy egyszerűbb példával azonban
bemutatjuk az engedélyek használatát. A PowerShellben két parancs-
elemmel lehet kezelni az engedélyeket: ezek a Get-Acl és a Set-Acl.
A parancselemek nevében szereplő főnév – az ACL – az access
control list kifejezés rövidítése, amelyet magyarul h o z z á f é r é s -
v e z é r l ő l i s t á n a k nevezünk. A Windows úgy valósítja meg a
hozzáférés engedélyezését, hogy minden fájlhoz és mappához hoz-
zárendel egy ilyen listát, amelynek minden sora egy felhasználónak
vagy felhasználócsoportnak felel meg. Az egyes felhasználók vagy
felhasználócsoportok azonosítói mellett feltünteti, hogy az adott fel-
használó vagy csoport milyen műveleteket végezhet – vagy nem vé-
gezhet – a fájlon vagy mappán. A lista egyes sorait h o z z á f é r é s -
v e z é r l ő b e j e g y z é s n e k (access control entry, ACE) nevezzük.
Az engedélyek kezelését nem tudjuk e könyvben részletesen bemu-
tatni, de az Olvasó számos forrást talál az irodalomjegyzékben.
A hozzáférés-vezérlő listákat talán úgy kezelhetjük a legköny-
nyebben, hogy az objektumhoz tartozó engedélyeket egy másik ob-
94
jektum engedélyeiről másoljuk le: Get-Acl eredetifajl.txt | Set-Acl

ujfajl.txt.
A feladat akkor válik bonyolulttá, amikor magunk szeretnénk to-
vábbi hozzáférésvezérlő-bejegyzéseket hozzáadni:
4.14. példa: Hozzáférési engedély hozzáadása fájlhoz
PS C:\> $acl = Get-Acl eredetifajl.csv
PS C:\> $accrule = New-Object
"System.Security.AccessControl.FileSystemAccessRule"
"LAP\Administrator",FullControl,Allow
PS C:\> $acl.AddAccessRule($accrule)
PS C:\> Set-Acl -Path ujfajl.csv -AclObject $acl
A példában az $acl nevű változóba írjuk az eredetifajl.csv fájlhoz tar-

tozó aktuális engedélyeket. Létre kell hoznunk egy új hozzáférés-ve-
zérlő bejegyzést, amelynek neve a .NET-keretrendszerben FileSystem-
AccessRule. Ennek létrehozásakor három paramétert kell megadnunk:
 a felhasználói fiók vagy csoport nevét, amelyre a szabály vo-

natkozik,
 az engedélyt magát – vagyis a műveleteket, amelyeket a fel-

használó vagy csoport elvégezhet: ez a jelen esetben a teljes
hozzáférés (FullControl), végül
 a bejegyzés típusát: tilthatjuk (Deny) vagy engedélyezhetjük
(Allow) az imént megadott műveletet.
A példában létrehozott $accrule változóban lévő szabályt az $acl vál-

tozó AddAccessRule metódusával adhatjuk hozzá a listához. Ne feled-
jük: az $acl változó az eredetifajl.csv fájlhoz tartozó engedélyeket tar-
talmazza. Végül a Set-Acl parancssor segítségével beállítjuk az $acl
változóban tárolt – új – engedélylistát az ujfajl.csv fájlra.
Látható, hogy ez nem tartozik a legkényelmesebben megoldható
feladatok közé. Lesznek talán olyan rendszergazdák, akik továbbra
is a cacls vagy Icacls nevű parancssori programot használják majd.
95
4.3. A fájlokhoz és mappákhoz tartozó engedélyek
Az alábbiakban felsoroljuk, hogy az új FileSystemAccessRule ob-

jektum létrehozásakor megadott engedély milyen műveletekre vo-
natkozhat:
Név Leírás
AppendData Adat hozzáfűzése meglévő fájlhoz
ChangePermissions Biztonsági és naplózási szabályok módosítása
CreateDirectories Mappák létrehozása (mappában)
CreateFiles Fájlok létrehozása (mappában)
Delete Az adott objektum törlése
DeleteSubdirectoriesAndFiles Az adott mappán belül található fájlok és mappák tör-
lése
ExecuteFile Fájl futtatása
FullControl Teljes hozzáférés
ListDirectory Mappa tartalmának kilistázása
Modify Objektum módosítása
Read Objektum olvasása
ReadAndExecute Fájl olvasása és futtatása
ReadAttributes Fájlrendszerbeli attribútumok olvasása (archív, csak
olvasható, rejtett, rendszer)
ReadData Fájl vagy mappa tartalmának olvasása
ReadExtendedAttributes Kiterjesztett attribútumok (metaadatok) olvasása (pl.
a dokumentum szerzője, évszám stb.)
ReadPermissions Biztonsági és naplózási szabályok elolvasása
TakeOwnership Az objektum saját tulajdonba vétele
Traverse Mappa bejárása
Write Objektum írása
WriteAttributes Az objektum fájlrendszerbeli attribútumainak módosí-
tása
WriteData Fájl vagy mappa tartalmának módosítása
WriteExtendedAttributes Kiterjesztett attribútumok (metaadatok) módosítása
96
ÖTÖDIK FEJEZET
A beállításjegyzék kezelése
5.1. A beállításjegyzék mint meghajtó

A hőskorban a Windows és annak összes alkalmazása minden beállí-
tást külön .ini fájlokban tárolt. Ez egy idő után meglehetősen átte-
kinthetetlenné és nehezen kezelhetővé vált. Ezt a problémát orvosol-
ta a Microsoft a Windows 95-ben bevezetett b e á l l í t á s j e g y z é k -
k e l (melynek akkor még regisztrációs adatbázis volt a neve, majd
később a rendszerleíró adatbázis nevet kapta; angolul: registry). Eb-
ben a programok hierarchikus szerkezetben, biztonságos módon tá-
rolhatják konfigurációs adataikat. Azóta ez a megoldás – többek kö-
zött támogatottsága és könnyen kezelhetősége miatt – rendkívül
népszerű lett: egy régóta, intenzíven használt számítógépen a beállí-
tásjegyzék mérete a több tíz, vagy akár a száz megabájtot is elérheti.1
A PowerShellben a beállításjegyzék két külön meghajtóként jele-
nik meg: egyik a HKLM névre hallgat, amelyből a HKEY_LOCAL_MA-
CHINE részfa alatt található kulcsokat és értékeket érhetjük el, a másik
a HKCU, amely a HKEY_CURRENT_USER rövidítése.
A Beállításszerkesztő (Registry Editor) programban látható a beállí-
tásjegyzék hierarchikus szerkezete. A beállításjegyzék elemeinek el-
nevezését az alábbi ábra mutatja.
1 A .NET-keretrendszer túllépett a beállításjegyzék keretein is: a .NET-

alkalmazások beállításait sok esetben már nem ott, hanem az alkalmazás-
sal egy mappában levő .config kiterjesztésű, XML-formátumú fájlokban
találjuk. Ezt a .NET fejlesztői az alkalmazások telepítésének egyszerűsíté-
sére és a verziókeveredés elkerülésére vezették be. (A szerk.)
5.1. A beállításjegyzék mint meghajtó
5.1. ábra: A beállításjegyzék szerkezete
A beállításjegyzék meghajtóihoz is a korábban már megismert Set-

Location parancselemmel juthatunk el: ehhez a Set-Location HKCU:, il-
letve a Set-Location HKLM: parancsot kell kiadnunk.
Ha önmagukban – a Set-Location parancselem nélkül – próbáljuk
kiadni a HKLM: vagy HKCU: parancsokat, azokat a PowerShell nem
tudja értelmezni, miközben a C:, D: stb. parancsok az elvárható mó-
don átváltanak a megfelelő meghajtóra. Ennek az a magyarázata, hogy
a PowerShell tanulásának megkönnyítésére a Microsoft létrehozott
26 függvényt A:-tól Z:-ig, melyek a Set-Location A: … Set-Location Z:
parancsokat adják ki. Erről magunk is megbizonyosodhatunk, ha ki-
listázzuk a Function: meghajtó tartalmát a Get-ChildItem Function:\
paranccsal, ugyanis a PowerShell függvénytára is külön meghajtó-
ként érhető el. Ha úgy kényelmesebb, a beállításjegyzék részfáihoz is
létrehozhatunk hasonló függvényeket:
98
5. fejezet: A beállításjegyzék kezelése
5.1. példa: Függvények a beállításjegyzék kulcsainak elérésére

function HKLM: { Set-Location HKLM: }
function HKCU: { Set-Location HKCU: }
5.2. A kulcsok kezelése

A beállításjegyzéket ugyanazokkal a parancselemekkel írhatjuk, ol-
vashatjuk és módosíthatjuk, amelyeket a fájlok kezelésére is használ-
tunk:
5.2. példa: A beállításjegyzék kulcsainak kilistázása
PS C:\> Set-Location HKCU:
PS HKCU:\> Set-Location Software
PS HKCU:\Software> New-Item Test
PS HKCU:\Software> Get-ChildItem T*
Hive: Microsoft.PowerShell.Core\Registry::HKEY_CURRENT_USER\Software
SKC VC Name Property

--- -- ---- --------
0 0 Test {}
1 0 Trolltech {}
Említettük, hogy a fenti példában használt parancselemeknek létezik

egyszerűbb álnevük: a Set-Location álneve a cd, a New-Item parancs-
elemé a md, a Get-ChildItem-é pedig a dir. Ezek is ugyanúgy használ-
hatók, mint az ige-főnév típusú parancselemek; a példákban azért
használjuk a teljes parancsnevet, hogy az Olvasó könnyebben meg-
szokja őket.
Kulcsokat törölni a Remove-Item kulcsnév, illetve kulcsokat átne-
vezni a Rename-Item -Path réginév -NewName újnév paranccsal tudunk.
99
5.3. Értékek módosítása
5.3. Értékek módosítása

A beállításjegyzék kulcsai alatt található bejegyzéseket, illetve azok
értékeit az ItemProperty főnévi tagú parancselemekkel kezelhetjük.
Ezek a következők:
Név Leírás
Clear-ItemProperty Bejegyzés értékének törlése (a parancselem meghagyja a be-
jegyzést)
Copy-ItemProperty Bejegyzés másolása
Get-ItemProperty Bejegyzés tulajdonságainak lekérdezése
Move-ItemProperty Bejegyzés átmozgatása másik kulcs alá
New-ItemProperty Új bejegyzés létrehozása
Remove-ItemProperty Bejegyzés eltávolítása
Rename-ItemProperty Bejegyzés átnevezése
Set-ItemProperty Meglévő bejegyzés értékének módosítása
Az alábbi példában létrehozunk egy bejegyzést, megváltoztatjuk az ér-

tékét, átmozgatjuk egy másik kulcs alá, majd lekérdezzük az értékét:
5.3. példa: Beállításjegyzék: bejegyzés létrehozása, módosítása, áthelyezése és lekérdezése
PS HKCU:\Software\Test> New-ItemProperty -Path . -Name alma -Value
kukac
PSPath : Microsoft.PowerShell.Core\Registry::HKEY_CURRENT_USER\Software\Test
PSParentPath : Microsoft.PowerShell.Core\Registry::HKEY_CURRENT_USER\Software
PSChildName : Test
PSDrive : HKCU
PSProvider : Microsoft.PowerShell.Core\Registry
alma : kukac
PS HKCU:\Software\Test> Set-ItemProperty -Path . -Name alma -Value mag

PS HKCU:\Software\Test> Move-ItemProperty -Path HKCU:\Software\Test -
Name alma -Destination HKCU:\Software
100

PS HKCU:\Software\Test> Set-Location ..
PS HKCU:\Software> Get-ItemProperty -Path .
PSPath : Microsoft.PowerShell.Core\Registry::HKEY_CURRENT_USER\Software
PSParentPath : Microsoft.PowerShell.Core\Registry::HKEY_CURRENT_USER
PSChildName : Software
PSDrive : HKCU
PSProvider : Microsoft.PowerShell.Core\Registry
alma : mag
A példában a „.” (pont) karaktert is használjuk elérési útként. Ez a

hagyományos Windows-parancssorhoz hasonlóan az aktuális map-
pát (most az aktuális beállításjegyzékbeli kulcsot) jelenti.
Látható, hogy a Get-ItemProperty parancs nemcsak az általunk igé-
nyelt bejegyzést adta vissza, hanem egyéb tulajdonságokat is, példá-
ul az adott kulcs teljes elérési útját, a PowerShell-meghajtó nevét stb.
Ha csak az általunk beállított bejegyzés értékére vagyunk kíváncsiak,
azt a (Get-ItemProperty -Path .).alma paranccsal kérdezhetjük le:
5.4. példa: Bejegyzés értékének lekérdezése a beállításjegyzékből
PS HKCU:\Software> (Get-ItemProperty -Path .).alma
mag
PS HKCU:\Software> $ertek=(Get-ItemProperty -Path .).alma
PS HKCU:\Software> if ($ertek -eq "mag") { "Az almában mag van." }
else { "Az almában nincs mag." }
Az almában mag van.
A PowerShell először kiértékeli a Get-ItemProperty parancsot, majd

az ott visszaadott gyűjteményből kiírja az alma tulajdonsághoz tarto-
zó értéket.
Tegyük fel, hogy felhasználóink számítógépén módosítani szeret-
nénk az Internet Explorer kezdőlapját, de csak ott, ahol a felhasználó
még nem állított be mást. Először ellenőriznünk kell, hogy a HKEY_
CURRENT_USER\Software\Microsoft\Internet Explorer\Main kulcs alatt ta-
lálható Start Page nevű bejegyzés értéke megegyezik-e az „about:blank”
karakterlánccal, és ha igen, akkor módosítanunk kell, mondjuk a
101
5.4. Engedélyek módosítása a beállításjegyzékben
http://intranet címre. Ehhez a következő szkriptet kell beállítanunk

bejelentkezési parancsfájlként:
5.5. példa: Beállításjegyzék: az Internet Explorer kezdőlapjának ellenőrzése és módosítása
PS HKCU:\Software> if ((Get-ItemProperty -Path
"HKCU:\Software\Microsoft\Internet Explorer\Main")."Start Page" -
eq "about:blank") { Set-ItemProperty -Path
"HKCU:\Software\Microsoft\Internet Explorer\Main" -Name "Start
Page" -Value "http://intranet" }
5.4. Engedélyek módosítása a

beállításjegyzékben
A Windowsban a beállításjegyzék kulcsaihoz is megadhatók engedé-
lyek, amelyek pontosan ugyanolyan hozzáférés-vezérlő listákban van-
nak tárolva, mint a fájlok és mappák esetén. A PowerShell-ben (pon-
tosabban a .NET-ben) ezért ugyanúgy kell kezelni a beállításjegyzék
engedélyeit, mint a fájlok esetén. A különbség az, hogy most nem
FileSystemAccessRule, hanem RegistryAccessRule típusú objektumokat
kell létrehoznunk – ezekben írhatjuk-olvashatjuk az engedélyeket.
Példa:
5.6. példa: Beállításjegyzék: hozzáférési engedély beállítása beállításjegyzék-beli
kulcsra
PS HKCU:\Software> $acl = Get-Acl Test
PS HKCU:\Software> $accrule = New-Object
"System.Security.AccessControl.RegistryAccessRule"
"LAP\Administrator",FullControl,Allow
PS HKCU:\Software> $acl.AddAccessRule($accrule)
PS HKCU:\Software> Set-Acl -Path Test -AclObject $acl
A példában az $acl nevű változónak értékül adjuk a Test kulcshoz

tartozó aktuális engedélyeket. Létre kell hoznunk egy új hozzáférés-
vezérlő bejegyzést: ezt a RegistryAccessRule osztály példányosításával
102
(egy RegistryAccessRule típusú változó létrehozásával) tehetjük meg.

A változó létrehozásakor, a FileSystemAccessRule objektumhoz ha-
sonlóan, három paramétert adunk meg:
 a felhasználói fiók vagy csoport nevét, amelyre a szabály vo-

natkozik,
 az engedélyezendő (vagy megtiltandó) műveletet vagy hozzá-

férési szintet (most ez a teljes hozzáférés), végül
 a hozzáférés-vezérlő bejegyzés típusát: a megadott művelete-

ket tilthatjuk (Deny) vagy engedélyezhetjük (Allow).
Az $accrule változóban létrehozott szabályt az $acl változó AddAc-

cessRule metódusával hozzáadjuk a Test kulcshoz tartozó – az $acl
változóba olvasott – engedélylistához, majd a Set-Acl parancselem-
mel az új listát érvényesítjük a Test kulcsra. Engedélyeket csak kul-
csokra állíthatunk be, az egyes bejegyzésekre nem.
A beállításjegyzék kulcsaihoz megadható művelet vagy hozzáfé-
rési szint – amelyet az új RegistryAccessRule objektum létrehozásakor
másodikként adunk meg – a következő lehet:
Név Leírás
ChangePermissions Biztonsági és naplózási szabályok módosítása
CreateSubKey A kulcson belül további alkulcsok létrehozása
Delete Az adott objektum törlése
EnumerateSubKeys Az adott kulcson belül található objektumok kilistázása
ExecuteKey Megegyezik a ReadKey engedéllyel
FullControl Teljes hozzáférés
Notify Kulcs módosításáról értesítés kérésének engedélyezése
QueryValues A bejegyzések értékeinek lekérdezése
ReadKey Kulcs olvasása
ReadPermissions Engedélyek olvasása
103
5.4. Engedélyek módosítása a beállításjegyzékben
Név Leírás
SetValue Meglévő bejegyzések értékének módosítása, új bejegyzések
létrehozása
TakeOwnership Az objektum saját tulajdonba vétele
WriteKey Összetett engedély, jogot ad bejegyzések és értékek létre-
hozására, törlésére, módosítására, alkulcsok létrehozására
és törlésére, módosítási értesítés kérésére, alkulcsok
kilistázására, valamint a hozzáférési jogosultságok és napló-
zási szabályok olvasására.
104
HATODIK FEJEZET
Haladó rendszerfelügyelet a
PowerShellel
6.1. A WMI kezelése

A W M I a Windows Management Instrumentation kifejezés rövidí-
tése, lefordítani Windows-beli felügyeleti műszerezésnek lehetne.
Kissé ferdítve a Windows műszerfaláról, olyan hívási pontok együt-
teséről van szó, amelyeken keresztül a rendszer állapotáról a legkü-
lönbözőbb dolgokat kérdezhetjük. Ahogy egy autóban külön műszer
mutatja a sebességet, a fordulatszámot, a hűtővíz hőmérsékletét, úgy
a WMI-től külön paraméterben kérdezhető a szabad merevlemez-
terület, a hálózat terhelése stb.
Rendkívül összetett, ám szabványos technológiáról van szó: a
WMI a DTMF (Desktop Management Task Force: munkacsoport asz-
tali rendszerek felügyeletének támogatására) nevű szervezet WBEM
(Web-Based Enterprise Management: webalapú vállalati szintű
rendszerfelügyelet) ajánlására épül.
A WMI egységes eszközrendszert ad arra, hogy programok a
rendszer elemeitől információt szerezzenek, illetve azokkal informá-
ciót közöljenek, és értesüljenek a rendszerben történő eseményekről.
A szabvány még az információszerzéshez használható lekérdező-
nyelvet is meghatározza – ez a nyelv különben az SQL szabályait
követi. A rendszergazda számára annak a jelentősége a legnagyobb,
hogy az operációs rendszerben alkalmazásprogramozói felület is
van, amelyen keresztül a WMI – tehát a rendszer – objektumai elér-
6.1. A WMI kezelése
hetők a legkülönbözőbb programozási nyelvekből (C#, Visual Basic

stb.), és a .NET-nek köszönhetően PowerShellből is.
A WMI Windows-alkalmazások (és parancsfájlok) számára hoz-
záférhető objektumtípusai a WIN32_eszközosztály nevet viselik. Ez
azért fontos, mert a parancsfájlokban ilyen névvel kell rájuk hivat-
kozni – amint azt a későbbi példák mutatják. A WMI teljes leírása
megtalálható (angolul) az MSDN webes változatában. 2008 augusz-
tusában ez a cím:
http://msdn2.microsoft.com/en-us/library/aa394572.aspx
A PowerShellben a WMI-osztályokat a Get-WmiObject osztály_neve

parancselemmel kérdezhetjük le. Bár a parancselem szintaxisa egy-
szerű, a számtalan WMI-osztálynak köszönhetően mégis rendkívül
sokoldalú és nagyon hatékony eszköz.
Példák:
6.1. példa: WMI-objektumok lekérdezése (fizikai memória, lemezek)
PS C:\> Get-WmiObject Win32_PhysicalMemory | Format-Table
BankLabel,Capacity,DataWidth -AutoSize
BankLabel Capacity DataWidth

--------- -------- ---------
Bank 0/1 536870912 64
Bank 2/3 536870912 64
PS C:\> Get-WmiObject Win32_Volume | Format-List

DriveLetter,Capacity,FreeSpace
DriveLetter : C:
Capacity : 78413557760
FreeSpace : 12300836864
DriveLetter : D:
Capacity : 1610608640
FreeSpace : 1240928256
106
6. fejezet: Haladó rendszerfelügyelet a PowerShellel

DriveLetter : E:
Capacity :
FreeSpace :
PS C:\> Get-WmiObject Win32_BIOS
SMBIOSBIOSVersion : 79ETC9WW (2.09 )

Manufacturer : LENOVO
Name : Phoenix FirstBIOS(tm) Notebook Pro Version 2.0
for ThinkPad
SerialNumber : L3FXY29
Version : LENOVO - 2090
PS C:\> (Get-WmiObject Win32_Processor).L2CacheSize.ToString()+"

kB"
2048 kB
PS C:\> if ((Get-WmiObject Win32_Processor).MaxClockSpeed -gt
1500) { "A processzor órajele 1500MHz felett van." }
A processzor órajele 1500MHz felett van.
A következő táblázatban felsorolunk néhány WMI-osztályt, a teljes-

ség igénye nélkül:
WMI-osztály Leírás
Win32_Desktop A felhasználó képernyő-beállításai (háttér,
képernyőkímélő stb.)
Win32_DesktopMonitor Monitorbeállítások (pl. felbontás)
Win32_DiskDrive A fizikai merevlemez típusa (méret, modellnév,
fizikai paraméterek stb.)
Win32_LoggedOnUser A számítógépre bejelentkezett felhasználók
Win32_NetworkAdapterConfiguration A hálózati csatolók tulajdonságai (név, IP-cím,
fizikai cím stb.)
Win32_NTDomain A számítógépről elérhető bejelentkezési tarto-
mányok (a helyi számítógép és valamennyi el-
érhető Active Directory-tartomány)
Win32_OperatingSystem Az operációs rendszer tulajdonságai (a telepí-
tett szervizcsomag, az operációs rendszer ki-
adása, a szabad memória nagysága, a telepítés
ideje, az utolsó rendszerindítás időpontja stb.)
107
6.2. Az Active Directory kezelése
WMI-osztály Leírás
Win32_PhysicalMemory A számítógépben található fizikai memória tu-
lajdonságai (helye az aljzatban, az adatsín szé-
lessége, a memóriamodul mérete stb.)
Win32_Process A futó folyamatok tulajdonságai
Win32_Processor A processzor tulajdonságai (a gyorsítótár mére-
te, órajel, a processzor neve stb.)
Win32_Product A telepített programok adatai (a termék neve,
a telepítés időpontja, azonosítója stb.)
Win32_Service A Windows-szolgáltatások tulajdonságai (rövid
és hosszú név, elérési út, a szolgáltatást futtató
felhasználó neve stb.)
Win32_Volume A merevlemezeken levő kötetek adatai (hozzá-
rendelt betűjel, sorozatszám, teljes méret,
szabad terület stb.)
A WMI-osztályok teljes listája megtalálható az előző oldalon említett

webcímen.

Az Active Directory-címtár a Windows-kiszolgálókra épülő hálózat
középpontja. Olyan szolgáltatásról van szó, amely központi adatbá-
zisban tárolja a felhasználók és számítógépek nyilvántartását és a há-
lózatban elérhető erőforrások (mappák, nyomtatók) hivatkozásait.
Így lehetővé teszi, hogy a számítógép-hálózatot egyetlen helyről fel-
ügyeljük, és jelentősen csökkenti a rendszerfelügyelet munkaigényét.
A címtárhasználatról és az Active Directory kezeléséről számos könyv-
ből lehet ismereteket szerezni; néhányat e könyv irodalomjegyzéké-
ben is felsoroltunk.
Rendszergazdaként talán a legfontosabb feladataink közé tartozik
a címtár karbantartása: új felhasználók felvétele, kilépett kollégák jo-
gainak megvonása, költözéskor szobaszám, telefonszám módosítása,
108
e-mail cím karbantartása stb. Amíg csak egy-egy felhasználóról van

szó, célszerűbb a módosításokat grafikus felületen, a megfelelő fel-
ügyeleti konzolon (MMC) elvégezni. Tömeges karbantartást azonban
célszerű lehet szkriptekkel végezni.
A PowerShell nem ad lehetőséget arra, hogy a beállításjegyzékhez
vagy a tanúsítványtárhoz hasonlóan a címtárt is meghajtóként érjük
el, azonban viszonylag könnyen hozzáférhetünk az A D S I felület-
hez. Az ADSI (Active Directory Services Interface – Active Directory
szolgáltatásfelületek) olyan COM-felületek gyűjteménye, amelyet
különböző hálózati szolgáltatások nyújtanak a címtárszolgáltatás
funkcióinak elérésére. Az ADSI segítségével elvégezhetők a rendsze-
res karbantartási feladatok; mégis könnyebb néhány műveletre más
eszközöket használni. Lássunk példát a PowerShell ADSI-felületének
használatára:
Kérdezzük le, majd írjuk át címtárbeli felhasználó nevét! Az ob-
jektum elérési útját az L D A P - féle k a n o n i k u s f o r m á b a n
kell megadnunk:1
6.2. példa: Active Directory-beli felhasználói fiók adatainak lekérdezése az ADSI-
felület segítségével
PS C:\> $adsi=[ADSI]"LDAP://CN=Teszt Elek,CN=Users,DC=teszt,DC=hu"
PS C:\> $adsi.sn
Elek
1 Az L D A P (Lightweight Directory Access Protocol) az az eljárás, amellyel a

címtárt használó számítógépek és programok hozzáférnek a címtárban tá-
rolt adatokhoz. A címtárban – a mappákhoz hasonlóan – az objektumok
tárolókba vannak rendezve, és egy tároló további tárolókat is tartalmaz-
hat. A kanonikus elérési út a címtárbeli objektum címét adja meg, a web-
címekhez és a tartománynevekhez hasonlóan a kisebb egységtől a na-
gyobb egység felé haladva. Az "LDAP://CN=Teszt Elek,CN=Users,DC=teszt,
DC=hu" elérési út a Teszt Elek nevű felhasználót jelenti, akinek fiókja a
Users tárolóban van, a tároló a teszt nevű tárolóban (tartományban – DC),
az pedig a hu nevű tárolóban (tartományban).
109

PS C:\> $adsi.givenName
Teszt
PS C:\> $adsi.displayName
Teszt Elek
PS C:\> $adsi.displayName="Teszt Béla"
PS C:\> $adsi.SetInfo()
Az első sorban az idézőjelek között megadtuk, hogy melyik címtár-

objektummal kívánunk foglalkozni. Bár a PowerShell nem érzékeny
a kis- és nagybetűkre, vagyis bármit írhatunk kis- vagy nagybetűvel,
megfelelően értelmezi, a fenti példában található LDAP:// karakter-
láncot kötelező nagybetűvel írni.
Az Active Directory címtárban vannak olyan beépített tárolók
(név szerint a Builtin, a Computers és a Users), amelyek tulajdonságait
nem módosíthatjuk, és amelyek nem is szervezeti egységek (OU).2
Ezekre a kanonikus névben a felhasználókhoz, csoportokhoz és
egyéb objektumokhoz hasonlóan a CN (Common Name, közönséges
név) taggal kell hivatkozni, míg szervezeti egységeket az OU (Organi-
zational Unit – szervezeti egység) betűk jelzik. A karakterlánc végén
adjuk meg az Active Directory-tartomány nevét, melynek tagjait [el-
választva ott, ahol a teljes tartománynévben pont (.) van] a DC (Doma-
in Context – tartományi környezet) karaktersorozat előzi meg. Tehát
a példában a teszt.hu/Users/Teszt Elek felhasználói fiók LDAP-szinta-
xisú kanonikus neve a példában szereplő CN=Teszt Elek, CN=Users,
DC=teszt,DC=hu. A felhasználói fiók tulajdonságait az $adsi változó
különböző tulajdonságain keresztül érhetjük el. Ha a változót beme-
2 Az Active Directory címtár az objektumokat (felhasználói fiókokat, szá-

mítógépeket, csoportokat, megoszott mappákat, nyomtatókat stb.) tarto-
mányokba, a tartományon belül pedig s z e r v e z e t i e g y s é g e k b e
(organizational unit, OU) rendezi. Ezek a mappákhoz hasonló logikai
struktúrát alkotnak, ám a tartomány általában fizikailag is elkülönölő há-
lózatrészt jelent, míg a szervezeti egység kizárólag az objektumok logikai
csoportosításra szolgál.
110
netként átadjuk a Get-Member parancselemnek, megjelennek a ren-

delkezésre álló tulajdonságok, de csak azok, amelyeknek már van ér-
tékük. Példánkban az sn tulajdonság a vezetéknevet (Surname) jelen-
ti, a givenName a keresztnév és a displayName a megjelenítendő név.
Ezeket a tulajdonságokat módosíthatjuk is. Ha ez megtörtént, az
új adatokat úgy írhatjuk vissza a címtárba, hogy meghívjuk az objek-
tum SetInfo() metódusát. Ha egy tulajdonság az Active Directory
címtárban (pontosabban annak sémájában) létezik, de az adott objek-
tumon (felhasználó, csoport stb.) még nincs értéke, azaz nincs beál-
lítva, akkor a fenti példában alkalmazott $adsi.tulajdonságnév szinta-
xis nem használható, ugyanis a SetInfo() meghívásakor hibát kapunk.
Új tulajdonságokat az objektum InvokeSet metódusával adhatunk a
címtári objektumokhoz:
6.3. példa: Active Directory-beli felhasználói fiók egy tulajdonságának módosítása
PS C:\> $adsi.psbase.InvokeSet("physicalDeliveryOfficeName","123.
szoba")
A physicalDeliveryOfficeName tulajdonság a szobaszámot jelenti.

Hasonlóképp tilthatunk le vagy engedélyezhetünk felhasználói
fiókokat:
6.4. példa: Letiltott Active Directory-beli felhasználói fiók engedélyezése
PS C:\> $adsi.psbase.InvokeSet("AccountDisabled",$false)
Az InvokeSet metódussal már meglévő tulajdonságok értékét is mó-

dosíthatjuk, így ha minden esetben ezt használjuk, nem kell előre
tudnunk, mely tulajdonságoknak van már értékük. A megjeleníten-
dő nevet így módosíthatjuk az InvokeSet metódussal:
6.5. példa: Active Directory-beli felhasználói fiók megjelenített nevének módosítása
PS C:\> $adsi.psbase.InvokeSet("displayName","Teszt Etel")
111
Ellenőrizzük, hogy a felhasználó tagja-e egy adott csoportnak:

6.6. példa: Active Directory-beli felhasználói fiók csoporttagságának ellenőrzése
PS C:\> $adsi.memberOf
CN=MINDENKI,CN=Users,DC=teszt,DC=hu
CN=TINYTERM,CN=Users,DC=teszt,DC=hu
CN=MSOFFICE,CN=Users,DC=teszt,DC=hu
PS C:\> if ($adsi.memberOf -notmatch "Domain Users") { "A felhasz-
náló nem tagja a tartományi felhasználóknak" }
A felhasználó nem tagja a tartományi felhasználóknak
Mivel Teszt Elek (vagy Teszt Béla? vagy Teszt Etel?) még nem tagja a
Domain Users csoportnak, adjuk hozzá! Ezt úgy tehetjük meg, hogy
előhívjuk a Domain Users csoportnak megfelelő objektumot, majd
meghívjuk az Add metódusát:
6.7. példa: Active Directory-beli felhasználói fiók felvétele a Domain Users csoportba
PS C:\> $adsi=[ADSI]"LDAP://CN=Domain
Users,CN=Users,DC=teszt,DC=hu"
PS C:\> $adsi.Add("LDAP://CN=Teszt Elek,CN=Users,DC=teszt,DC=hu")
A csoportból tagot eltávolítani a Remove metódussal lehet:

6.8. példa: Active Directory-beli felhasználói fiók eltávolítása a Domain Users cso-
portból
PS C:\> $adsi.Remove("LDAP://CN=Teszt
Elek,CN=Users,DC=teszt,DC=hu")
Megjegyezzük, hogy az Active Directory felépítéséből adódóan a

csoporttagságok között nem szerepel a felhasználó elsődleges cso-
portja.
Ha szükséges, meg is változtathatjuk egy felhasználó jelszavát. A
művelet végrehajtásához nem szükséges rendszergazdai jogkörrel
rendelkezni, ha tudjuk a régi jelszót:
6.9. példa: Active Directory-beli felhasználói fiók jelszavának módosítása
PS C:\> $user=[ADSI]"LDAP://CN=Teszt Elek,CN=Users,DC=teszt,DC=hu"
PS C:\> $user.ChangePassword("RegiJelszo","UjJelszo")
112
Ha a régi jelszó nem áll rendelkezésünkre, rendszergazdaként át is

írhatjuk azt (mint ahogy azt az Active Directory Users and Computers
konzolban is tennénk):
6.10. példa: Active Directory-beli felhasználói fiók jelszavának beállítása
PS C:\> $user.SetPassword("UjJelszo")
Új felhasználót ugyancsak nem nehéz létrehozni, de ennek megérté-

séhez előbb tennünk kell egy kis kitérőt. Nem módosíthatjuk a fel-
használói fiók tulajdonságait az előtt, hogy az létezne. A gyakorlat-
ban ez azt jelenti, hogy miután kiadtuk a felhasználói fiókot létreho-
zó parancsot, meg kell hívnunk az objektum SetInfo metódusát, és
csak azután adhatjuk meg a többi tulajdonságot, beleértve a felhasz-
náló jelszavát is.
Hogyan hozzunk létre felhasználói fiókot, ha nincs jelszava, de a
tartományi házirend szerint a jelszavaknak mégis meg kell felelniük
bizonyos feltételeknek? Ezt az ellentmondást az Active Directory
úgy oldja fel, hogy ilyenkor létrejön egy jelszóval nem rendelkező,
letiltott felhasználói fiók, amelynek jelszót adnunk, mielőtt engedé-
lyeznénk:
6.11. példa: Felhasználói fiók létrehozása az Active Directory címtárban
PS C:\> $adsi=[ADSI]"LDAP://CN=Users,DC=teszt,DC=hu"
PS C:\> $user=$adsi.Create("User","CN=Ejtő Ernő")
PS C:\> $user.SetInfo()
PS C:\> $user.sn="Ejtő" #Vezetéknév
PS C:\> $user.givenName="Ernő" #Keresztnév
PS C:\> $user.sAMAccountName="ejtoerno" #Windows 2000 előtti
felhasználónév
PS C:\> $user.userPrincipalName="ejtoerno@teszt.hu" # „kukacos”
felhasználónév
PS C:\> $user.displayName="Ejtő Ernő" #Megjelenítendő név
PS C:\> $user.description="Ő Ernő" #Megjegyzés
PS C:\> $user.telephoneNumber="123" #Telefonszám
PS C:\> $user.physicalDeliveryOfficeName="234" #Szobaszám
PS C:\> $user.SetInfo() #Adatok beállítása
113

PS C:\> $user.SetPassword("Jelszo123") #Jelszó módosítása
PS C:\> $user.psbase.InvokeSet("AccountDisabled",$false) #Fiók
engedélyezése
PS C:\> $user.pwdLastSet=0 #Következő bejelentkezéskor jelszót
kell cserélni
PS C:\> $user.SetInfo() #Adatok beállítása
Egy, már létező felhasználót a Delete metódussal törölhetünk:

6.12. példa: Active Directory-beli felhasználói fiók törlése
PS C:\> $adsi=[ADSI]"LDAP://CN=Users,DC=teszt,DC=hu"
PS C:\> $adsi.Delete("User","CN=Ejtő Ernő")
Az Active Directory-val kapcsolatban egy olyan gyakori feladat van,

amelyet a PowerShell natív eszközeivel nem tudunk megoldani: ez
az objektumok keresése. Ilyenkor segítségül hívhatjuk a Windows Ser-
ver részét képező felügyeleti csomagot (ezt Windows Server 2003 alatt
Administration Tools Pack-nek hívják, Windows Server 2008 alatt pe-
dig a Remote Server Administration Tools névre hallgat). Ennek
ugyanis részét képezik a parancssori „ds”-parancsok: dsadd, dsget,
dsmod, dsmove, dsquery és dsrm. Ebből számunkra a dsquery az érdekes,
amely számos feltétel szerint tud keresni a címtárban. Az alábbi szkript
kiírja a tartomány összes felhasználójának megjelenítendő nevét:
6.13. példa: Active Directory-tartomány összes felhasználói fiókja megjelenítendő
nevének kiírása
PS C:\> dsquery user -limit 0 | ForEach-Object {
>> $object="LDAP://"+$_.Replace("`"","")
>> $adsi=[ADSI]$object
>> $adsi.displayName
>> }
>>
A dsquery alapértelmezés szerint csak az első 100 objektumot adja

vissza, így a –limit 0 paramétert is meg kell adnunk, ha minden talá-
latra kíváncsiak vagyunk. A dsquery egy karakterláncokból álló gyűj-
114
teményben adja vissza a felhasználók kanonikus neveit. Ennek az

elemeit dolgozzuk fel a ForEach-Object parancselemmel. A dsquery a
kanonikus neveket idézőjelek közé írja, azokat a $_.Replace("`"","")
paranccsal lehet eltávolítani.
Tegyük fel, hogy nem tudjuk, hol található Teszt Elek nevű fel-
használónk (aki a TesztE bejelentkező nevet kapta), de szeretnénk
megváltoztatni a hozzá tartozó leírást:
6.14. példa: Active Directory-beli felhasználói fiók megkeresése és leírásának módosítása
PS C:\> dsquery user -samid TesztE | ForEach-Object {
>> $object="LDAP://"+$_.Replace("`"","")
>> $adsi=[ADSI]$object
>> $adsi.description="Ez itt Teszt Elek"
>> $adsi.SetInfo()
>> }
>>
6.3. SQL-adatbázisok kezelése

Nagyobb rendszerfelügyeleti feladatok során szükség lehet arra,
hogy bizonyos adatokat SQL-adatbázisból olvassunk ki, vagy adat-
bázisba írjunk. Habár a PowerShell nem támogatja beépített eszkö-
zökkel az SQL-kiszolgálók3 kezelését, a .NET-keretrendszer lehető-
séget ad erre. Íme egy egyszerű példa, amely kiolvassa egy tábla tar-
talmát:
6.15. példa: Tábla kiolvasása SQL-adatbázisból
PS C:\> $conn = New-Object "System.Data.SqlClient.SqlConnection"
"Server=DC;Database=master;Integrated Security=True"
PS C:\> $conn.Open()
PS C:\> $command = New-Object "System.Data.SqlClient.SqlCommand"
"SELECT * FROM [spt_monitor]",$conn
3 A leírás feltételezi, hogy az SQL-kiszolgáló a Microsoft SQL Server

adatbáziskezelő rendszerrel működik.
115
6.3. SQL-adatbázisok kezelése

PS C:\> $reader = $command.ExecuteReader()
PS C:\> while ($reader.Read()) {
>> $reader[0].ToString()+":"+$reader[1].ToString()
>> }
>>
2005.10.14. 1:53:53:8
PS C:\> $reader.Close()
PS C:\> $conn.Close()
Először létre kell hoznunk egy SqlConnection típusú objektumot,

melynek paraméterként megadjuk a kapcsolat létrehozásához szük-
séges k a p c s o l a t s z t r i n g e t (connection string). A példában ez
Ez a karakterlánc az adatbázis-kiszolgáló nevéből (DC), a használni
kívánt adatbázis nevéből és az Integrated Security=True paraméterből
áll. Az utóbbival azt határozzuk meg, hogy az SQL–kiszolgálóhoz a
jelenlegi felhasználó nevében szeretnénk csatlakozni, az integrált
Windows–hitelesítés révén. A kapcsolatsztringek használatára a
www.connectionstrings.com oldalon számos példát találunk.
Miután létrehoztuk a kapcsolati objektumot, az Open() metódus-
sal meg kell nyitnunk a kapcsolatot. Ezután létre kell hoznunk egy
SqlCommand típusú objektumot, amelynek két paramétert kell meg-
adni: magát az SQL-kérést, illetve azt a kapcsolatot, amelyre a lekér-
dezést szeretnénk lefuttatni.
Ezután három lehetőségünk van:
1. Ha az SQL-lekérdezés egy táblával (értsd: több mezőnyi és sornyi
adattal) tér vissza, a SqlCommand objektum ExecuteReader() metó-
dusát kell meghívnunk, majd a példában látható módon kiolvasni
az eredményt a változóból. Itt a while utasítás feltételeként meg-
adott $reader.Read() az SQL kiszolgálóval fennálló nyitott kapcso-
laton keresztül beolvassa a következő rekordot a $reader változó-
ba. Az első mezőre a $reader[0], a másodikra a $reader[1] stb. ki-
fejezéssel hivatkozhatunk. Ha ismerjük a mezők nevét (pl. mezo1,
mezo2 stb.), akkor a $reader["mezo1"], $reader["mezo2"] stb. kife-
116
jezések is a kívánt értékeket adják vissza. Ilyenkor a .NET az

SQL–kiszolgálótól kapott adatokat nem látja el típussal. Ehelyett
minden adatot object típusúként adja vissza, amelyet a ToString()
metódussal lehet karakterlánccá alakítani. Ha kiolvastuk az ösz-
szes szükséges adatot, a $reader változó Close() metódusának hí-
vásával jelezzük a kiszolgáló felé, hogy nincs szükségünk több
rekordra, így az felszabadíthatja az erőforrásokat.
2. Ha az SQL-lekérdezés eredménye egyetlen érték, használjuk az
ExecuteScalar() metódust! Ilyen lekérdezés például a SELECT
MAX([id]) FROM [azEnTablam]. Ha a kiszolgáló nemcsak egy sort és
egy oszlopot adna vissza, az ExecuteScalar() akkor is csak az első
rekord első mezőjével tér vissza.
3. Ha az SQL-lekérdezés nem tér vissza értékkel (ilyen az INSERT, az

UPDATE vagy a DELETE), az ExecuteNonQuery() metódust kell fut-
tatnunk. Ez olyan egész számot ad vissza, amelyből megtudhat-
juk, hogy a kérés hány sort érintett (például az UPDATE utasítás
hány értéket módosított).
Ha befejeztük a munkát az SQL-kiszolgálóval, ne felejtsük el lezárni

a kapcsolatot! Ehhez a kapcsolatobjektum (a példában a $conn válto-
zó) Close metódusát kell meghívni.
6.4. A rendszer kezelése szkriptekkel

Az előzőekben végigvettük a PowerShell-nek a rendszer karbantar-
tásához szükséges legfontosabb alapelemeit. A következőkben való-
di példákkal mutatjuk be a PowerShell lehetőségeit. Természetesen
nem adhatunk minden esetre kész szkripteket, de megpróbáljuk be-
mutatni a leggyakoribb felhasználási módokat, a többit pedig az Ol-
vasó fantáziájára bízzuk. Az itt található szkriptek túlnyomó többsé-
ge – kisebb-nagyobb eltérésekkel – megtalálható az előző fejezetek-
117
ben, azokat a részeket pedig, amelyeket még nem mutattunk be,

részletesen megmagyarázzuk.
Elsőként nézzük meg, miként tudunk egy .csv fájlból az Active
Directory címtárba felhasználókat felvenni:
6.16. példa: Több felhasználó felvétele az Active Directory címtárba CSV-fájlból
Import-Csv users.csv | ForEach-Object {
$cn="LDAP://OU="+$_.OU+",DC=teszt,DC=hu"
$adsi=[ADSI]$cn
$fullname=$_.Surname+" "+$_.GivenName
$user=$adsi.Create("User","CN="+$fullname)
$user.SetInfo()
$user.sn=$_.Surname
$user.givenName=$_.GivenName
$user.sAMAccountName=$_.Username
$user.userPrincipalName=$_.Username+"@teszt.hu"
$user.displayName=$fullname
$user.telephoneNumber=$_.Phone
$user.physicalDeliveryOfficeName=$_.Office
$user.SetInfo()
$user.SetPassword($_.Password)
$user.psbase.InvokeSet("AccountDisabled",$false)
$user.pwdLastSet=0
$user.SetInfo()
}
A fenti szkript az adatokat egy olyan .csv fájlból olvassa be, amely-
ben Surname, GivenName, Username, Phone, Office, Password és OU fej-
lécű oszlopok találhatók. Példa:
Surname,GivenName,Username,Phone,Office,Password,OU
Bakt,Ernő,bakterno,100,201,Titok123,Cégvezetés
Bal,Margó,balmargo,101,202,Titok234,Cégvezetés
Bekre,Pál,bekrepal,102,203,Titok345,Cégvezetés
...
Vegyük figyelembe, hogy a fenti .csv fájlt angol (amerikai) területi

beállítás mellett hozta létre a szerző. Magyar beállítások mellett a
vessző helyett pontosvesszőt látunk a mezők között.
118
Második példánkban keressük meg azokat a fájlokat, amelyekhez

már legalább két hete nem nyúltak, majd erről írjunk jelentést az
eseménynaplóba:
6.17. példa: A két hétnél régebben nem használt fájlok megkeresése, jelentés írása az
eseménynaplóba
PS C:\> $regifajlok=""
PS C:\> Get-ChildItem -Recurse | Where-Object { $_.LastAccessTime
-lt (Get-Date).AddDays(-14) } | ForEach-Object {
$regifajlok+=$_.FullName+"`n" }
PS C:\> if ([System.Diagnostics.EventLog]::SourceExists("Régi fáj-
lok")) { [System.Diagnostics.EventLog]::CreateEventSource("Régi
fáj-lok","Application") }
PS C:\> [System.Diagnostics.EventLog]::WriteEntry("Régi fájlok","A
mai ellenőrzés során az alábbi régi fájlokat
találuk:`n"+$regifajlok,[System.Diagnostics.EventLogEntryType]::In
formation,1000)
A példában, miután a $regifajlok változóban összegyűjtöttük a 14

napnál régebben használt fájlok nevét, a System.Diagnostics.EventLog
osztály SourceExists metódusával ellenőrizzük, hogy létezik-e már a
Régi fájlok nevű eseményforrás. Ha nem, a CreateEventSource metó-
dussal létrehozzuk azt az alkalmazásnaplóban (Application log). Ez-
után a WriteEntry függvénnyel új eseményt írunk az eseménynaplóba.
Ennek négy argumentumot adunk meg: az esemény forrását, az ese-
mény üzenetét, az esemény típusát (amelyet a System.Diagnostics.
EventLogEntryType osztály Error, Warning vagy Information tulajdon-
ságával határozhatunk meg), valamint az esemény azonosítóját.
A harmadik példában írjunk olyan szkriptet, amely ellenőrzi,
hogy az eseménynapló tartalmaz-e olyan, kritikus hibákat jelző ese-
ményeket, amelyek az elmúlt 24 órában keletkeztek, és ha igen, e-
mailben értesítést küld:
119
6.18. példa: Az utolsó 24 órában keletkezett, kritikus hibákat jelző események megke-
resése az eseménynaplóban; értesítő e-mail küldése
PS C:\> $msg=""
PS C:\> Get-EventLog Application |
>> Where-Object { $_.TimeWritten -gt (Get-Date).AddDays(-1) -and
$_.EntryType -eq "Error" } |
>> ForEach-Object {
>> $msg+="Idő: "+$_.TimeWritten+"`n"
>> $msg+="Típus: "+$_.EntryType+"`n"
>> $msg+="Forrás: "+$_.Source+"`n"
>> $msg+="Azonosító: "+$_.EventID+"`n"
>> $msg+="Üzenet: "+$_.Message+"`n`n" }
>>
PS C:\> $smtp = New-Object "System.Net.Mail.SmtpClient"
"smtp.ceg.hu"
PS C:\>
$smtp.Send("felado.ferenc@ceg.hu","cimzett.cecil@ceg.hu","Az utób-
bi 24 órában keletkezett hibák",$msg)
Először kigyűjtjük az eseménynapló alkalmazásnaplójából azokat a

24 óránál nem régebbi eseményeket, melyek hibát jeleznek, majd eze-
ket hozzáadjuk egy karakterlánchoz. Ezután létrehozzuk az SmtpClient
osztály egy példányát, melynek megadjuk az SMTP-kiszolgáló (a le-
vélkiszolgáló) nevét vagy IP-címét. A levél elküldéséhez az SmtpClient
típusú objektum (a példában a $smtp változó) Send metódusát kell
meghívni a következő négy paraméterrel: feladó e-mail-címe, cím-
zett e-mail-címe, az üzenet tárgya és az üzenet szövege. Esetünkben
ez az $msg változó tartalma. Ezt a szkriptet tovább is finomíthatjuk,
ha például csak azokat az eseményeket szeretnénk összegyűjteni,
amelyeknek a forrása egy lemezmeghajtó.
Következő példánk egy naplógyűjtő parancsfájl. Azon cégeknek,
amelyek igazán biztonságos infrastruktúrát kívánnak kialakítani,
szükségük lehet egy n a p l ó g y ű j t ő k i s z o l g á l ó r a (log server),
amelyen a hálózat összes kiszolgálójának naplóbejegyzéseit rögzítik,
megnehezítve a nyomok eltüntetését egy esetleges betörés esetén.
Erre a célra számos megoldást vehetünk készen, de általában igen
magas áron.
120
Most házilag összeállítunk egy ilyen rendszert a PowerShell és a

Microsoft SQL Server segítségével. Először is szükségünk lesz egy
különálló számítógépre, amelyre telepítjük az SQL Server progra-
mot. (Ha kiszolgálónként nem kívánunk 4GB-nál több naplót meg-
tartani, elegendő lehet az SQL Server rendszer Express változata,
amely ingyen elérhető.)
Az adatbázis-kiszolgálón minden olyan számítógép számára
hozzunk létre egy adatbázist, amelyről a naplóeseményeket gyűjteni
szeretnénk; minden adatbázis neve a számítógép á l l o m á s n e v e
(hostname) legyen. Ezekben az adatbázisokban hozzunk létre táblákat
az egyes naplók számára. A táblák neve egyezzen meg a napló ne-
vével. Ha az alkalmazásnaplót és a rendszernaplót kívánjuk rögzíte-
ni, akkor a táblák neve Application és System legyen (magyar Win-
dows esetén Alkalmazás és Rendszer). Az egyes táblák szerkezetét a
6.1. ábra mutatja.
6.1. ábra: A naplóadatbázis adatszerkezete
Az alábbi szkriptet rendszeresen le kell futtatni minden olyan számí-

tógépen, amelynek a naplóbejegyzéseit az adatbázisban tárolni kí-
vánjuk. A szkriptet tetszőleges időközökre időzíthetjük.
121
6.19. példa: Naplók gyűjtése közös SQL-adatbázisba több különböző kiszolgálóról

$log="Application","System"
##############################################################
$hostname=(Get-ChildItem Env:\ComputerName).Value
$conn = New-Object "System.Data.SqlClient.SqlConnection" "Data

Source=LOG;Initial Catalog=$hostname;Integrated Security=SSPI;"
$conn.Open()
$command = New-Object "System.Data.SqlClient.SqlCommand" "",$conn
foreach ($thislog in $log) {

$date=(Get-Date)
Get-EventLog $thislog | Where-Object { $_.TimeWritten -gt (Get-
ItemProperty -Path HKLM:\SOFTWARE\Log -Name $thislog).$thislog } |
Sort-Object -Descending | ForEach-Object {
$index=$_.Index
$entrytype=$_.EntryType
$eventid=$_.EventID
$message=$_.Message.Replace("'","`"")
$source=$_.Source
$timegenerated=$_.TimeGenerated
$timewritten=$_.TimeWritten
$username=$_.UserName
$command.CommandText="INSERT INTO [$thislog] ([In-
dex],[EntryType],[EventID],[Message],[Source],[TimeGenerated],[Tim
eWritten],[UserName]) VALUES
('$index','$entrytype','$eventid','$message','$source','$timegener
ated','$timewritten','$username')"
$rows=$command.ExecuteNonQuery() }
Set-ItemProperty -Path HKLM:\SOFTWARE\Log -Name $thislog -Value
"$date" }
$conn.Close()
Először a $log változóban meghatározzuk, hogy mely naplók esemé-

nyeit kell lekérdezni, majd a $hostname változóban eltároljuk a szá-
mítógép állomásnevét, melyet a ComputerName nevű környezeti vál-
tozóból olvasunk ki – a környezeti változókat tartalmazó Env: meg-
hajtóról. Létrehozunk egy SQL-kapcsolatot a LOG nevű kiszolgáló
122
$hostname adatbázisával, majd megnyitjuk az adatbázist, és előkészí-

tünk egy SQL-parancsot is.
Végigmegyünk a $log nevű gyűjtemény elemein, és a következőt
tesszük velük: a $date változóban eltároljuk az aktuális dátumot,
majd lekérdezzük az adott napló olyan eseményeit, melyek a leg-
utolsó lekérdezés óta keletkeztek. A legutolsó lekérdezés dátumát a
beállításjegyzék HKEY_LOCAL_MACHINE\Software\Log kulcs naplóneve
bejegyzéséből olvassuk ki, melyet a szkript első futtatása előtt ma-
gunknak kell létrehoznunk, és ott REG_SZ (karakterlánc) típusú be-
jegyzésekbe beírni a gyűjtendő naplók nevét. Az eseményeket fordí-
tott sorrendben dolgozzuk fel.
Minden naplóbejegyzés legfontosabb tulajdonságait eltároljuk
egy-egy változóban. Ezután a $command változóban előkészített SQL-
parancs CommandText tulajdonságában összeállítjuk azt az INSERT ké-
rést, amely beszúrja az aktuális bejegyzést az adatbázisba. A kérést
aztán az ExecuteNonQuery() metódussal hajtjuk végre.
Ha egy adott napló minden bejegyzését feldolgoztuk, frissítjük a
beállításjegyzékben az adott naplóhoz tartozó dátumot azzal az idő-
ponttal, amelyet a művelet elején elhelyeztünk a $date változóban.
Azért célszerű ezt a feldolgozás kezdetekor rögzíteni és csak a végén
frissíteni, mert nagyobb rendszereken a feldolgozás akár több percig
is eltarthat, és a késleltetés miatt fontos események kimaradhatnak
az adatbázisból. Mikor minden naplót feldolgoztunk, lezárjuk az
SQL-kapcsolatot.
Ötödik, egyszerű példánkban olyan szkriptet írunk, amely az IIS
webkiszolgáló naplófájljait elemzi. Feltételezzük, hogy a naplók W3C
Extended típusúak.
123
6.20. példa: Az IIS webkiszolgáló naplóinak elemzése; annak meghatározása, hogy

melyik IP-címről hány kérés érkezett
$ip=""
Get-Content C:\Windows\System32\LogFiles\W3SVC1\ex080728.log |
ForEach-Object {
$tomb=$_.Split(" ")
if (-not $tomb[0].StartsWith("#")) { $ip+=$tomb[9]+"," }
}
$ip.Split(",") | Group-Object
A rövid szkript soronként beolvassa a megadott naplófájlt, széttörde-

li a sorokat a szóközök mentén, majd a 10. oszlop tartalmát (amely-
ben az ügyfelek IP-címe található) hozzáfűzi az $ip változóhoz.
Mindezt akkor, ha a sor (vagyis annak első oszlopa) nem a # karak-
terrel kezdődik, a # karakter ugyanis a megjegyzéseket jelöli a napló-
fájlban.
Ezután a vesszők mentén szétszedjük az $ip változóban található
IP-címeket, mindegyiket tömbbé alakítjuk, majd ezt bemenetként át-
adjuk a Group-Object parancselemnek. Utóbbi megmondja, hogy me-
lyik IP-címről mennyi kérés érkezett. Hasonlóképpen a böngészők
típusából (a 11. oszlop adataiból) is készíthetünk statisztikát:
6.21. példa: Az IIS webkiszolgáló naplóinak elemzése; statisztika készítése a böngé-
szők típusa szerint
$browser=""
Get-Content C:\Windows\System32\LogFiles\W3SVC1\ex080728.log |
ForEach-Object {
$tomb=$_.Split(" ")
if (-not $arr[0].StartsWith("#")) { $browser+=$tomb[10]+"," }
}
$browser.Split(",") | Group-Object
A szkriptet tovább is bővíthetjük: a Get-ChildItem parancselemmel

előbb lekérdezzük az adott webhelyhez tartozó valamennyi naplóál-
lományt (C:\Windows\System32\LogFiles\W3SVC1), és az azokban ta-
lálható összes adatot feldolgozzuk.
124
HETEDIK FEJEZET
Az Exchange Server 2007 és

a PowerShell
A Microsoft legújabb fejlesztéseiben szemlátomást arra törekszik,

hogy „PowerShellesítse” valamennyi termék kezelését. Ez azt jelenti,
hogy a termék összes tulajdonságát csak a PowerShellből lehet elér-
ni, a grafikus kezelőfelület pedig a PowerShell előtétje, és a háttérben
tulajdonképpen az is PowerShell-szkripteket futtat. Az első ilyen
termék az Exchange Server 2007 volt; azóta kiadtak egy lemezes
mentőrendszert (Microsoft System Center Data Protection Manager 2007),
és a könyv írásakor még megjelenésre váró Microsoft ForeFront Threat
Management Gateway rendszert, amely az ISA Server – a Microsoft
tűzfalrendszere – utódja lesz. E két termék is PowerShell-alapú keze-
lőfelületet kapott.
E könyv témája a PowerShell, így az Exchange Server témáját is e
szempontból közelítjük meg. Feltételezzük, hogy az Olvasónak már
vannak előzetes ismeretei az Exchange Server 2007-ről. Könyvünk
irodalomjegyzéke mindenesetre az Exchange Server-ről is felsorol
könyveket.
7.1. A PowerShell beépülő moduljai

Ha elindítjuk a PowerShellt, abban nem érhetők el az Exchange Ser-
ver parancselemei. Ha az Exchange Management Shell programot
indítjuk, ott igen, pedig az is csak PowerShell. Mi a különbség? Az
Exchange Management Shell is a powershell.exe programot indítja el,
7.2. Postaládák létrehozása
de speciálisan paraméterezi. Mielőtt megkapnánk a PowerShell pa-

rancssorát, betöltődik egy b e é p ü l ő m o d u l (snap-in) is. Ez tu-
lajdonképpen egy .dll-fájl, amely meghatározza a rendelkezésre álló
parancselemeket, azok argumentumait és a hatásukra végrehajtandó
.NET-műveleteket. Ha szkriptet írunk az Exchange Server kezelésé-
re, és automatizálva szeretnénk futtatni, az Exchange Server pa-
rancselemeinek használata előtt be kell töltenünk a beépülő modult:
7.1. példa: Beépülő modul betöltése a PowerShellbe
PS C:\> Add-PSSnapin Microsoft.Exchange.Management.PowerShell.Admin
7.2. Postaládák létrehozása

Bár a PowerShellben nem könnyű az Active Directory címtárt kezel-
ni, az Exchange Server 2007 kezelőfelülete kínál olyan parancseleme-
ket, amelyek segítségével a címtárt is kezelhetjük. Ezek közül talán a
New-Mailbox a legfontosabb, amely a postaláda mellett felhasználói
fiókot is létrehoz. (Ha már meglévő felhasználónak szeretnénk posta-
ládát létrehozni, azt az Enable-Mailbox parancselemmel tehetjük meg.)
A New-Mailbox rendkívül részletesen paraméterezhető; most csak a
legfontosabbakat adjuk meg. A New-Mailbox argumentumait és azok
használatát a Get-Help New-Mailbox parancs mutatja meg részletesen.
Vegyük a legegyszerűbb esetet, egy felhasználói fiók létrehozását:
7.2. példa: Új felhasználói fiók és új postaláda létrehozása az Exchange Server
rendszerben
[PS] C:\>$pass = Read-Host -AsSecureString
******
[PS] C:\>New-Mailbox -Name "Teszt Elek" -Database "Mailbox
Database" -Password $pass -UserPrincipalName tesztelek@teszt.hu
A fenti példában először beolvassuk a billentyűzetről a létrehozni

kívánt felhasználó jelszavát egy változóba, biztonságos karakter-
126
7. fejezet: Az Exchange Server és a PowerShell
láncként. A SecureString a .NET-keretrendszer egy típusa, amelyben

titkos, biztonsági szempontból fontos szövegeket (jellemzően jelsza-
vakat) tárolhatunk. Ezt a legegyszerűbben a billentyűzetről olvashat-
juk be, megadva a Read-Host parancselemhez az –AsSecureString pa-
ramétert is. Ha az Olvasó szereti a kihívásokat, másképp is létrehoz-
hat biztonságos karakterláncot:
7.3. példa: Biztonságos karakterlánc létrehozása karakterenként
[PS] C:\>$pass = New-Object "System.Security.SecureString"
[PS] C:\>$pass.AppendChar("t")
[PS] C:\>$pass.AppendChar("i")
[PS] C:\>$pass.AppendChar("t")
[PS] C:\>$pass.AppendChar("o")
[PS] C:\>$pass.AppendChar("k")
Miután létrejött a biztonságos karakterlánc, meghívjuk a New-Mailbox

parancselemet, paraméterként megadva a felhasználó nevét, a posta-
ládát tároló adatbázis nevét, a jelszót és az UPN-t.
A 6. fejezetben megírt, felhasználókat létrehozó parancsfájlunkat
is továbbfejleszthetjük úgy, hogy az a New-Mailbox parancselemet
használja:
7.4. példa: CSV-fájlban felsorolt felhasználók létrehozása a New-Mailbox
parancselemmel
[PS] C:\>Import-Csv users.csv | ForEach-Object {
>> $pass = New-Object "System.Security.SecureString"
>> for ($i=0; $i -lt $_.Password.Length; $i++) {
$pass.AppendChar($_.Password[$i]) }
>> $name = $_.Surname+" "+$_.GivenName
>> $upn = $_.Username+"@teszt.hu"
>> New-Mailbox -Name $name -Database "Mailbox Database" -
Password $pass -UserPrincipalName $upn -SamAccountName $_.Username
-DisplayName $name -FirstName $_.GivenName -LastName $_.Surname -
OrganizationalUnit $_.OU -ResetPasswordOnNextLogon $true
>> }
>>
127
7.3. A postaládák méretének meghatározása
7.3. A postaládák méretének

meghatározása
Többször láthattuk, hogy a PowerShell nagy segítség az adatok szű-
résében, keresésében, rendszerezésében. Az Exchange Server 2007 fej-
lesztői nem adtak a kezünkbe grafikus eszközt a postaládák komo-
lyabb karbantartására, így a legtöbb feladatot parancssorból kell meg-
oldanunk. Többek között ilyen a postaládák méretének lekérdezése
is, amit a Get-MailboxFolderStatistics parancselemmel tehetünk meg:
7.5. példa: Az Exchange-postaládák méretének lekérdezése, az adatok táblázatos
megjelenítése
[PS] C:\>Get-MailboxFolderStatistics martonsz | Format-Table
Date Name Identity FolderPat FolderId FolderTyp ItemsInFo FolderSiz ItemsInFo FolderAnd
h e lder e lderAndSu Subfolder
bfolders Size
---- ---- -------- --------- -------- --------- --------- --------- --------- ---------
2008. ... Top of... martonsz\ / LgAAAA... Root 0 0B 1475 37955161B
2008. ... Calendar marton... /Calendar LgAAAA... Calendar 9 13535B 9 13535B
2008. ... Contacts marton... /Contacts LgAAAA... Contacts 126 49624B 126 49624B
2008. ... Conver... marton... /Conve... LgAAAA... Commun... 2 7784B 2 7784B
2008. ... Delete... marton... /Delet... LgAAAA... Delete... 1 136B 1 136B
2008. ... Drafts marton... /Drafts LgAAAA... Drafts 3 1010979B 3 1010979B
2008. ... Inbox marton... /Inbox LgAAAA... Inbox 944 30071629B 944 30071629B
2008. ... Journal marton... /Journal LgAAAA... Journal 12 40095B 12 40095B
2008. ... Junk E... marton... /Junk ... LgAAAA... JunkEmail 0 0B 0 0B
2008. ... Notes marton... /Notes LgAAAA... Notes 1 680B 1 680B
2008. ... Outbox marton... /Outbox LgAAAA... Outbox 0 0B 0 0B
2008. ... RSS Su... marton... /RSS S... LgAAAA... RssSub... 0 0B 0 0B
2008. ... Sent I... marton... /Sent ... LgAAAA... SentItems 373 6746562B 373 6746562B
2008. ... Sync I... marton... /Sync ... LgAAAA... SyncIs... 0 0B 3 14001B
2008. ... Conflicts marton... /Sync ... LgAAAA... Conflicts 3 14001B 3 14001B
2008. ... Local ... marton... /Sync ... LgAAAA... LocalF... 0 0B 0 0B

2008. ... Server... marton... /Sync ... LgAAAA... Server... 0 0B 0 0B
2008. ... Tasks marton... /Tasks LgAAAA... Tasks 1 136B 1 136B
128
A parancs önmagában csak egy postaláda adatait jeleníti meg, de

annak az összes almappáját is kiírja – rengeteg, számunkra egyelőre
felesleges információval. A Get-Mailbox parancselem visszaadja az
Exchange szervezet összes postaládáját. Ennek kimenetét továbbad-
juk a Get-MailboxFolderStatistics parancselemnek, majd az így kapott
listából kiszűrjük azokat az elemeket, ahol a FolderPath tulajdonság
megegyezik a „/” karakterlánccal. Ezután a listát a FolderAndSub-
folderSize tulajdonság alapján csökkenő sorrendbe rendezzük. A
FolderAndSubfolderSize tulajdonság az adott mappa – jelen esetben a
gyökérmappa – és valamennyi almappájának méretét tartalmazza.
7.6. példa: A három legnagyobb Exchange-postaláda kilistázása
[PS] C:\>Get-Mailbox | Get-MailboxFolderStatistics | Where-Object
{ $_.FolderPath -eq "/" } | Sort-Object FolderAndSubfolderSize -
Descending | Select-Object -First 3 | Format-Table
Identity,FolderAndSubFolderSize
Identity FolderAndSubfolderSize
-------- ----------------------
teszt.hu/Users/Quarantine\ 154344249B
teszt.hu/Users/Gipsz Jakab\ 143494613B
teszt.hu/Users/Mekk Elek\ 142644337B
7.4. Az Exchange-kiszolgáló
megfigyelése
Gyakran előfordul, hogy a felhasználók megkeresik a rendszergaz-
dát, hogy miért „nyelte el” a rendszer az e-mailjüket. Ezt nem min-
dig könnyű kinyomozni. Amikor pedig a főnök kérdezi meg, hogy a
legfontosabb ügyfél levele miért pattan vissza, akkor igazán hasznos,
ha gyorsan utána tudunk nézni az egyes üzeneteknek, és ki tudjuk
deríteni a hiba okát. Keressük meg azokat az e-maileket, amelyek a
mai napon jöttek (vagy csak próbáltak jönni) a teszt@partner.hu címről:
129
7.4. Az Exchange-kiszolgáló megfigyelése
7.7. példa: Adott e-mail-címről érkező levelek megkeresése az Exchange

levéltovábbító ügynökének naplójában
[PS] C:\>Get-AgentLog -StartDate (Get-Date -Hour 0 -Minute 0 -Second 0)
| Where-Object { $_.P1FromAddress -match "teszt@partner.hu" } | Format-
Table TimeStamp,P1FromAddress,Recipients,Action,Reason -AutoSize
Timestamp P1FromAddress Recipients Action

--------- ------------- ---------- ------
2008.07.29 0:27:53 teszt@partner.hu {mekke@ceg.hu} AcceptMessage
2008.07.29 0:28:01 teszt@partner.hu {gipsz@ceg.hu} AcceptMessage
2008.07.29 0:28:01 teszt@partner.hu {teszt@ceg.hu} RejectMessage
A példában a Get-AgentLog parancselemmel lekérdezzük az Exchan-

ge-kiszolgáló – tulajdonképpen a l e v é l t o v á b b í t ó ü g y n ö k –
naplóját. A parancselemnek paraméterként megadjuk a mai dátu-
mot. Az így kapott listát (gyűjteményt) megszűrjük a Where-Object
parancselemmel, hogy csak azokat a naplóbejegyzéseket adja vissza,
ahol az üzenet küldője a teszt@partner.hu. Az eredményt a Format-
Table parancselemmel táblázatként formázzuk, ahol a táblázat osz-
lopai a küldés ideje, a feladó címe, a címzett címe és a kiszolgáló által
az üzeneten végzett művelet (AcceptMessage – üzenet elfogadva,
RejectMessage – üzenet elutasítva).
Figyelem! A Get-AgentLog parancselem csak olyan Exchange-ki-
szolgálón működik, amely az Edge szerepkört futtatja (végponti to-
vábbítókiszolgáló), vagy olyan Hub (központi továbbító) kiszolgáló-
kon, amelyekre telepítettük a levélszemét-szűrő ügynököket.
Ez természetesen egyszerűsített példa. A a naplót számos feltétel
szerint tovább szűrhetjük, és tetszőleges részletességgel nyerhetünk
ki belőle adatokat.
Egy 2007. évi adat szerint az internet teljes e-mail-forgalmának
kb. 88-90%-a l e v é l s z e m é t (spam). Tudja-e az Olvasó, hogy saját
munkahelyén milyen ez az arány? E szám ismerete hatásos fegyver,
ha a vezetőség a levelezést kritizálja: a rendszergazda a mellényzse-
béből előrántja a számokat, melyek szerint egy napon például 4000 e-
mailt küldenek a céghez, és ebből 3600 levélszemét.
130
Most készítsünk statisztikát a levélszemétről! Először a Get-

AgentLog parancselemmel kérdezzük le az aznapi e-mail-forgalmat,
és közben szűrjük ki
 azokat a bejövő leveleket, amelyeket a rendszer beengedett,

 a visszautasított bejövő leveleket (ez a levélszemét),
 azokat a bejövő leveleket, amelyek vélhetően szemétlevelek,

de a biztonság kedvéért beengedtük őket (ezek S C L - é r t é -
k e 5 felett van) és
 a kimenő leveleket.
Állítsuk be a feladatütemezőt, hogy a végponti továbbítókiszolgálón

(Edge) naponta futtassa le a következő szkriptet:
7.8. példa: Statisztika készítése a napi e-mail-forgalomról: fogadott levelek,
levélszemét, valószínű levélszemét, kimenő levelek
[PS] C:\>$belso="10.0.0.5" #a központi kiszolgáló IP-címe
[PS] C:\>Add-PSSnapin Microsoft.Exchange.Management.PowerShell.Admin
[PS] C:\>$today=(Get-Date).Date.AddDays(-1)
[PS] C:\>$tomorrow=$today.AddDays(1)
[PS] C:\>$todayslog=(Get-AgentLog -StartDate $today -EndDate $tomorrow)
[PS] C:\>$accept=($todayslog| Where-Object { $_.Action -like
"AcceptMessage" } | Where-Object { $_.IPAddress -ne $belso }).count
[PS] C:\>$reject=($todayslog | Where-Object { $_.Action -like "Reject*"
} | Where-Object { $_.IPAddress -ne $belso }).count
[PS] C:\>$spam=($todayslog | Where-Object { $_.Action -like
"AcceptMessage" } | Where-Object { $_.ReasonData -gt 5 } | Where-Object
{ [PS] C:\>$_.IPAddress -ne $belso }).count
[PS] C:\>$accept=$accept-$spam
[PS] C:\>$sent=($todayslog | Where-Object { $_.IPAddress -eq $belso
}).count
[PS] C:\>$sum=($todayslog).count
[PS] C:\>$todaystring=$today.ToString().SubString(0,10)
[PS] C:\>if ($sent -lt 1) { $sent="0"; }
[PS] C:\>"$todaystring;$accept;$reject;$spam;$sent;$sum" | Out-File
C:\Scripts\Spam.csv -append
131
7.4. Az Exchange-kiszolgáló megfigyelése
Ez a szkript minden nap hozzáfűzi egy .csv-fájlhoz az előző napi e-

mail-forgalom adatait. A fájl a következő oszlopokat tartalmazza:
 Dátum
 Elfogadott e-mailek száma

 Visszautasított e-mailek száma
 Beengedett gyanús e-mailek száma
 Kiküldött e-mailek száma
 Az összes e-mail száma
Ha ezt a .csv-fájlt megnyitjuk az Excel programmal, tetszetős halmo-

zott oszlop/henger (Stacked Column/Cylinder) diagramot készíthe-
tünk belőle, és további statisztikai számításokat is végezhetünk (át-
lagos e-mail-mennyiség, szórás stb).
132
NYOLCADIK FEJEZET
A PowerShell bővítése
A PowerShell a .NET-keretrendszerre épül. Egyszerűsítve azt is

mondhatnánk, hogy egyszerűbb kezelőfelületet ad a keretrendszer
azon lehetőségeihez, amelyek hasznosak lehetnek a rendszergazdai
feladatok ellátása során. Ez azt is jelenti, hogy a PowerShell szolgál-
tatásai elég könnyen bővíthetők. Ezt mások már megtették: több
hasznos segédprogram is létezik szkriptek írására, adatok megjelení-
tésére és a parancselemek bővítésére. E fejezetben először a segéd-
programokkal foglalkozunk, majd pedig mi magunk írunk olyan
egyszerű ASP.NET-alkalmazást, amely a PowerShell segítségével
nyert adatokat jeleníti meg.
8.1. Külső eszközök
PowerShell Community Extensions
Letölthető a n y í l t f o r r á s k ó d ú projekteknek otthont adó

Codeplexről, a http://www.codeplex.com/PowerShellCX címről.
Néhány lelkes PowerShell-felhasználó úgy gondolta, hogy a Mic-
rosoft által nyújtott parancselemek köre nem elegendő, ezért írtak
néhány újabb parancselemet. Ízelítőként felsorolunk néhány hasznos
parancsot:
8.1. Külső eszközök
Parancselem Leírás
Get-Clipboard, Objektumok beolvasása a vágólapról, illetve kiírása a vágólapra

Set-Clipboard
Ping-Host Hálózati eszköz pingelése ICMP-csomaggal
Resolve-Host Állomásnév (DNS-név) feloldása IP-címre
Get-Random Véletlenszám előállítása
New-Shortcut Új parancsikon létrehozása
Get-Shortpath Hosszú fájlnevek 8.3-as formátumú változatának megjelenítése
Send-SmtpMail E-mail küldése az SMTP-protokollal
Write-Gzip Fájlok tömörítése a GZIP algoritmussal
Write-Zip Fájlok tömörítése a ZIP algoritmussal
A Community Extensions által telepített beépülő modul teljes parancs-

elem-listáját a fent említett webcímen található „readme” fájlban ta-
láljuk.
PowerGUI
A PowerGUI fejlesztői hálózati közösséget is létrehoztak a www.po-

wergui.org webhelyen, ahonnan maga a program is letölthető. A
PowerGUI segítségével a leggyakoribb rendszerfelügyeleti teendőket
(folyamatok és szolgáltatások kezelése, a beállításjegyzék módosítá-
sa, a felhasználói fiókok karbantartása stb.) könnyen kezelhető grafi-
kus felületen végezhetjük el. Ugyanitt meg is tekinthetjük a művele-
tekhez szükséges parancsokat. Kezdő PowerShell-ezők számára pe-
dig tökéletes tanulási eszköz.
134
8. fejezet: A PowerShell bővítése
8.1. ábra: A PowerGUI program képernyője
PowerShell Analyzer
A PowerShell Analyzer (www.powershell.com) kereskedelmi termék.

A 45 napig használható próbaverzióban minden funkció működik,
és nagyon jól mutatja, mire képes a program. A PowerShell Analyzer
összetett alkalmazás, amelynek talán legfontosabb képessége, hogy
PowerShell szkripteket szerkeszthetünk és egysoros parancsokat fut-
tathatunk benne, illetve a PowerShellből kinyert adatokat, diagra-
mokként is megjeleníthetjük. A szerkesztéshez nagy segítséget nyújt
a Visual Studióból ismert IntelliSense technológia, vagyis az, hogy a
parancselem nevének gépelése közben már megjelenít egy listát az
addig begépelt karakterekre illeszkedő parancsokkal. Megmutatja az
egyes parancsok használatát, paraméterezését is, és a parancsok fut-
tatása közben segít a hibakeresésben.
135
8.2. ASP.NET-alkalmazás fejlesztése
8.2. ábra: A PowerShell Analyzer program képernyője

Az alábbiakban röviden leírjuk, miként lehet olyan webalkalmazást
írni, amely megjeleníti a futó folyamatok listáját a legfontosabb ada-
taikkal együtt, úgy, hogy az adatok lekérdezéséhez a Get-Process pa-
rancselemet használja. A példában szereplő program semmi esetre
sem tekinthető teljesnek: hiányzik belőle a hibakezelés, hiányoznak a
biztonsági megfontolások, és a kód sem mondható „szépnek”. Nem
136
javasoljuk a kód változtatás nélküli felhasználását. Egyetlen célunk,

hogy megismertessük az Olvasót a PowerShell programozásával.
Az ASP.NET-alkalmazás létrehozásához szükségünk lesz a Mic-
rosoft Visual Studio 2005 vagy 2008 rendszerre.
Az ASP.NET-alkalmazás elkészítéséhez hajtsuk végre az alábbi
lépéseket:
1. Hozzunk létre a Visual Studio programban egy új Web Site típusú

projektet, akár Visual Basic, akár C# nyelven!
2. Az új webhelyhez adjunk hozzá egy új hivatkozást: nyissuk meg

a webhelyhez tartozó web.config fájlt, majd ott a configuration/sys-
tem.web/complication rész alá szúrjuk be az alábbi XML-részletet:
8.1. példa: A PowerShell-szkript futtatásának engedélyezése egy webhely

konfigurációjában
<assemblies>
<add assembly="System.Management.Automation, Version=1.0.0.0,
Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
</assemblies>
3. A Default.aspx fájl tartalmát írjuk felül az alábbi kóddal (előbb a

Visual Basic- majd a Visual C#-kód következik):
8.2. példa: A futó folyamatok listájának megjelenítése egy weboldalon Visual
Basic.NET-ben programozva
<%@ Page Language="VB" AutoEventWireup="false"
CodeFile="Default.aspx.vb" Inherits="_Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title>Futó folyamatok</title>
</head>
137

<body>
<table border="1">
<tr><td>Id</td><td>ProcessName</td><td>WorkingSet</td></tr>
<%
Dim rsConfig As
System.Management.Automation.Runspaces.RunspaceConfiguration
rsConfig =
System.Management.Automation.Runspaces.RunspaceConfiguration.Create()
Dim myRunSpace As
System.Management.Automation.Runspaces.Runspace
myRunSpace =
System.Management.Automation.Runspaces.RunspaceFactory.CreateRunspace
(rsConfig)
myRunSpace.Open()
Dim pipeLine As System.Management.Automation.Runspaces.Pipeline
pipeLine = myRunSpace.CreatePipeline()
pipeLine.Commands.AddScript("Get-Process")
For Each result As System.Management.Automation.PSObject In
pipeLine.Invoke()
Response.Write("<tr>")
Response.Write("<td>" +
result.Members("Id").Value.ToString() + "</td>")
result.Members("ProcessName").Value.ToString() + "</td>")
result.Members("WorkingSet").Value.ToString() + "</td>")
Response.Write("</tr>")
Next
%>
</table>
</body>
</html>
138
8.3. példa: A futó folyamatok listájának megjelenítése egy weboldalon Visual

C#.NET-ben programozva
<%@ Page Language="C#" AutoEventWireup="true"
CodeFile="Default.aspx.cs" Inherits="_Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title>Futó folyamatok</title>
</head>
<body>
<table border="1">
<tr><td>Id</td><td>ProcessName</td><td>WorkingSet</td></tr>
<%
System.Management.Automation.Runspaces.RunspaceConfiguration
rsConfig =
System.Management.Automation.Runspaces.RunspaceConfiguration.Create();
System.Management.Automation.Runspaces.Runspace myRunSpace =
System.Management.Automation.Runspaces.RunspaceFactory.CreateRunspace
(rsConfig);
myRunSpace.Open();
System.Management.Automation.Runspaces.Pipeline pipeLine =
myRunSpace.CreatePipeline();
pipeLine.Commands.AddScript("Get-Process");
foreach (System.Management.Automation.PSObject result in
pipeLine.Invoke())
{
Response.Write("<tr>");
result.Members["Id"].Value.ToString() + "</td>");
result.Members["ProcessName"].Value.ToString() + "</td>");
result.Members["WorkingSet"].Value.ToString() + "</td>");
Response.Write("</tr>");
}
%>
</table>
</body>
</html>
4. Jelenítsük meg az oldalt a Debug menü Start Debugging parancsával!
139
A FÜGGELÉK
A példák jegyzéke
Ebben a függelékben kulcsszavak szerint felsoroljuk a nyolc fejezet

példáit. A kulcsszavak között a példák témájára jellemző fontosabb
szakkifejezések, a példákban alkalmazott PowerShell-parancselemek
szerepelnek. A jegyzékben egy példa többször is megjelenhet.
A kulcsszavak alatt minden sorban egy példa oldalszáma, sor-
száma és leírása látható. A példák emellett megtalálhatók a könyv-
höz tartozó webhelyen (http://www.powershellkonyv.hu) is.
16-os számrendszer
64 2.49 Számok kiíratása 16-os számrendszerben
65 2.50 Számok kiíratása 16-os számrendszerben, nagybetűkkel
65 2.51 Számok kiíratása 16-os számrendszerben, jobbra zárva
ábécésorrend
55 2.35 A könyvtárlista kiíratása név szerinti ábécésorrendben
Active Directory
109 6.2 Active Directory-beli felhasználói fiók adatainak lekérdezése az ADSI-
111 6.3 Active Directory-beli felhasználói fiók egy tulajdonságának módosítása
111 6.4 Letiltott Active Directory-beli felhasználói fiók engedélyezése
111 6.5 Active Directory-beli felhasználói fiók megjelenített nevének módosítása
112 6.6 Active Directory-beli felhasználói fiók csoporttagságának ellenőrzése
112 6.7 Active Directory-beli felhasználói fiók felvétele a Domain Users csoportba
112 6.8 Active Directory-beli felhasználói fiók eltávolítása a Domain Users
csoportból
112 6.9 Active Directory-beli felhasználói fiók jelszavának módosítása
113 6.10 Active Directory-beli felhasználói fiók jelszavának beállítása
113 6.11 Felhasználói fiók létrehozása az Active Directory címtárban
114 6.12 Active Directory-beli felhasználói fiók törlése
Active Directory-tartomány
114 6.13 Active Directory-tartomány összes felhasználói fiókja megjelenítendő

nevének kiírása
115 6.14 Active Directory-beli felhasználói fiók megkeresése és leírásának mó-
dosítása
118 6.16 Több felhasználó felvétele az Active Directory címtárba CSV-fájlból
Active Directory-tartomány
nevének kiírása
adatmező
63 2.45 Adatmezők formázása az -f operátorral
63 2.46 Adatok formázása jobbra zárva az -f operátorral
64 2.47 Formázósablon alkalmazása az -f operátorral
Add-PSSnapin
126 7.1 Beépülő modul betöltése a PowerShellbe
131 7.8 Statisztika készítése a napi e-mail-forgalomról: fogadott levelek, levél-
szemét, valószínű levélszemét, kimenő levelek
aktuális dátum
76 3.12 Az aktuális dátum változóba helyezése, egy nap hozzáadása
76 3.13 Egy nap hozzáadása az aktuális dátumhoz
90 4.6 A .doc kiterjesztésű fájlok áthelyezése egy, az aktuális dátumról elne-
vezett mappába
aktuális dátum és idő
35 2.2 Az aktuális dátum és idő változóba helyezése, majd kiíratása
66 2.55 Dátum- és időértékek formázása; a pontos idő kiíratása az aktuális
időt és dátumot tartalmazó objektumból
67 2.56 A teljes dátum és idő kiíratása az aktuális dátumot és időt tartalmazó
objektumból
aktuális mappa
77 3.14 A legalább két hete nem használt objektumok megkeresése az aktuális
mappában
91 4.7 A Push-Location és a Pop-Location parancselemek használata
53 2.32 Az aktuális mappában levő fájlok méretének összegzése
54 2.33 Az aktuális mappában levő fájlok átlagos méretének kiszámítása
54 2.34 Az aktuális mappában levő .exe fájlok méretének összegzése
56 2.37 Az aktuális mappában levő 5 legkisebb fájl kilistázása
57 2.38 Az aktuális mappában levő 3 legrégebben módosított fájl kilistázása
142
böngésző típusa
aláírás
85 3.23 PowerShell-szkript aláírása tanúsítvánnyal
alkönyvtár
53 2.30 Könyvtárlista összegyűjtése alkönyvtárakból is; meghatározott nevű
fájlok kiválogatása a Where-Object parancselemmel és reguláris kife-
jezésekkel
aritmetikai művelet
45 2.19 Bonyolultabb aritmetikai műveletek
áthelyezés
88 4.2 A .doc kiterjesztésű fájlok áthelyezése, a többi fájl kitörlése adott
mappából
átlagszámítás
beállításjegyzék
99 5.1 Függvények a beállításjegyzék kulcsainak elérésére
99 5.2 A beállításjegyzék kulcsainak kilistázása
100 5.3 Beállításjegyzék: bejegyzés létrehozása, módosítása, áthelyezése és le-
kérdezése
101 5.4 Bejegyzés értékének lekérdezése a beállításjegyzékből
102 5.5 Beállításjegyzék: az Internet Explorer kezdőlapjának ellenőrzése és
módosítása
102 5.6 Beállításjegyzék: hozzáférési engedély beállítása beállításjegyzék-beli
kulcsra
beépülő modul
billentyűzet
50 2.26 Számok beolvasása a billentyűzetről, amíg a felhasználó 0-t nem gépel
50 2.27 Számok beolvasása a billentyűzetről, amíg a felhasználó 0-t nem gé-
pel; hátul tesztelő while ciklussal
biztonságos karakterlánc
127 7.3 Biztonságos karakterlánc létrehozása karakterenként
böngésző típusa
124 6.21 Az IIS webkiszolgáló naplóinak elemzése; statisztika készítése a bön-
gészők típusa szerint
143
C#
C#
139 8.3 A futó folyamatok listájának megjelenítése egy weboldalon Visual
Cert:
84 3.21 A tanúsítványtár mint meghajtó kezelése
ciklus
48 2.23 A for ciklus
49 2.24 A ciklusváltozó módosítása a for ciklus magjában
Compare-Object
59 2.42 Két gyűjtemény összehasonlítása; folyamatok listájának változóba he-
lyezése és az újonnan elindított folyamatok észlelése
-contains
42 2.14 Karakterláncok összehasonlítása
44 2.16 Az if operátor használata
csoport
csoportból
csoportok elemeinek megszámolása
58 2.41 Az egyes csoportok elemeinek megszámolása csoportosított gyűjte-
ményben (most épp könyvtárlistában)
csoportosítás
57 2.40 Könyvtárlista mint gyűjtemény elemeinek csoportosítása a fájlok ki-
terjesztése szerint
csoporttagság
csoportból
CSV-fájl beolvasása
93 4.12 CSV-fájl beolvasása objektumgyűjteménybe
93 4.13 Meghatározott nevű objektumok beolvasása CSV-fájlból
144
e-mail-cím

127 7.4 CSV-fájlban felsorolt felhasználók létrehozása a New-Mailbox pa-
rancselemmel
dátum
78 3.15 Dátumok kivonása, időtartam kiszámítása
89 4.3 Év, hónap és nap hibás összefűzése dátumban
89 4.4 Év, hónap és nap majdnem helyes összefűzése dátumban
89 4.5 Év, hónap és nap helyes összefűzése dátumban
objektumból
dátumok kivonása
dir
dsquery
nevének kiírása
dosítása
egyelés
57 2.39 Gyűjtemény ismétlődő elemeinek kihagyása
e-mail
e-mail küldése
120 6.18 Az utolsó 24 órában keletkezett, kritikus hibákat jelző események
megkeresése az eseménynaplóban; értesítő e-mail küldése
e-mail-cím
129 7.7 Adott e-mail-címről érkező levelek megkeresése az Exchange levélto-
vábbító ügynökének naplójában
145
e-mail-forgalom
e-mail-forgalom
engedély
95 4.14 Hozzáférési engedély hozzáadása fájlhoz
kulcsra
-eq
eseménynapló
79 3.16 A rendszernaplóban levő 10 legújabb esemény kiíratása
80 3.17 A lemezalrendszer (Disk forrás) eseményeinek kiíratása a rendszer-
naplóból
80 3.18 Adott forrásból származó, a rendszernaplóba az elmúlt 24 órában be-
írt események megkeresése
81 3.19 Adott forrásból származó, legfeljebb 3, legfeljebb 1 napos esemény kiírása
119 6.17 A két hétnél régebben nem használt fájlok megkeresése, jelentés írása
az eseménynaplóba
122 6.19 Naplók gyűjtése közös SQL-adatbázisba több különböző kiszolgálóról
Exchange Server
126 7.2 Új felhasználói fiók és új postaláda létrehozása az Exchange Server
rendszerben
rancselemmel
128 7.5 Az Exchange-postaládák méretének lekérdezése, az adatok táblázatos
megjelenítése
129 7.6 A három legnagyobb Exchange-postaláda kilistázása
146
fájlkiterjesztés
-f
64 2.48 Könyvtárlista formázása táblázatként az -f operátorral
65 2.52 Számok kiíratása pénzösszegként, a pénznem megjelölésével
65 2.53 Számok kiíratása pénzösszegként, a pénznem megjelölésével, a terüle-
ti beállítás módosítása után
65 2.54 Számok kiíratása százalékos értékként
objektumból
67 2.57 Lebegőpontos számok (most épp a ) kiíratása adott pontossággal
67 2.58 Lebegőpontos számok (most épp a ) kiíratása 3 tizedesjegyre kerekítve
fájl
mappából
vezett mappába
91 4.8 Fájlok letöltése szövegfájlban felsorolt URL-címekről
az eseménynaplóba
fájl beolvasása
fájlkiterjesztés
147
felhasználói fiók
felhasználói fiók
111 6.3 Active Directory-beli felhasználói fiók egy tulajdonságának módosítása
111 6.5 Active Directory-beli felhasználói fiók megjelenített nevének módosítása
csoportból
114 6.12 Active Directory-beli felhasználói fiók törlése
nevének kiírása
dosítása
rendszerben
felhasználói fiók létrehozása
rendszerben
rancselemmel
fizikai memória
106 6.1 WMI-objektumok lekérdezése (fizikai memória, lemezek)
folyamat
72 3.7 A folyamatok listájának kiíratása
73 3.8 Az 50 MB-nál több memóriát használó folyamatok kilistázása
74 3.9 A legtöbb memóriát használó folyamat leállítása
75 3.10 Folyamat sikeres leállításának ellenőrzése
75 3.11 A nem válaszoló folyamatok megkeresése
148
Format-List

folyamatlista
for ciklus
49 2.24 A ciklusváltozó módosítása a for ciklus magjában
49 2.25 Sok kép automatikus letöltése egy webhelyről
ForEach-Object
88 4.2 A .doc kiterjesztésű fájlok áthelyezése, a többi fájl kitörlése adott mappából
92 4.11 Szövegfájl soraiban tárolt parancsok futtatása
nevének kiírása
dosítása
Format-List
61 2.44 A könyvtárlista átformázása listaként
149
Format-Table
Format-Table
60 2.43 A könyvtárlista átformázása táblázatként
formázás
megjelenítése
formázósablon
function
69 3.1 Függvény létrehozása és érték visszaadása
69 3.2 Függvény, amely eltávolítja a szóközöket egy karakterláncból
70 3.4 Függvény, amely megfordítja a bájtokat egy IP-címben
71 3.5 Függvény, amely megfordítja egy IP-cím bájtjait – szövegszerkesztő-
ben megírva
futtatás
91 4.9 Karakterláncban tárolt parancs futtatása
92 4.10 Változóban tárolt parancs futtatása
függvény
70 3.3 A szóközöket eltávolító függvény kipróbálása
ben megírva
71 3.6 Függvény kódjának beillesztése a PowerShellbe
-ge
41 2.13 Számok összehasonlítása
150
Get-ChildItem
Get-Acl
kulcsra
Get-AgentLog
Get-ChildItem
33 2.1 Könyvtárlista kiíratása
39 2.10 A könyvtárlista változóba helyezése és kezelése gyűjteményként
51 2.28 Válogatás a könyvtárlistából a Where-Object parancselemmel
jezésekkel
56 2.36 A könyvtárlista kiíratása az utolsó módosítás ideje szerinti fordított
időrendben
mappában
85 3.22 Tanúsítvány megkeresése a tanúsítványtárban
151
Get-Content
az eseménynaplóba
Get-Content
124 6.20 Az IIS webkiszolgáló naplóinak elemzése; annak meghatározása,
hogy melyik IP-címről hány kérés érkezett
Get-Date
35 2.3 Időértékek kivonása: két időpont között eltelt idő kiszámítása
objektumból
mappában
Get-EventLog
naplóból
152
Group-Object
Get-Help
87 4.1 Az -Item végű parancselemek kilistázása
Get-ItemProperty
módosítása
Get-Mailbox
Get-MailboxFolderStatistics
megjelenítése
Get-Member
36 2.4 Karakterlánc metódusainak és tulajdonságainak lekérdezése
Get-Process
Get-WmiObject
Group-Object
153
-gt

-gt
gyökértanúsítvány
84 3.20 Gyökértanúsítvány, majd PowerShell-szkriptek futtatásához szüksé-
ges tanúsítvány létrehozása
gyűjtemény
38 2.9 Karakterlánc felbontása szavakra, a szavakból gyűjtemény létrehozása
39 2.11 Gyűjtemény létrehozása kézzel
40 2.12 Adatok megadása konstansként
53 2.31 Kézzel létrehozott gyűjtemény szűrése a Where-Object parancselemmel
115 6.15 Tábla kiolvasása SQL-adatbázisból
hátul tesztelő while ciklus
hexadecimális
hozzáférési engedély
kulcsra
154
IP-cím
idő
időrendben
objektumból
időtartam
if
IIS
Import-Csv
rancselemmel
Internet Explorer
módosítása
Invoke-Expression
IP-cím
ben megírva
155
ismétlődő elemek kihagyása

ismétlődő elemek kihagyása
jelszó
jobbra zárás
karakterlánc
37 2.5 Keresés és csere karakterláncban
37 2.6 Karakterlánc részének kivágása
38 2.7 Keresés és csere karakterláncban, majd rész kiemelése
38 2.8 Karakterlánc elejének és végének vizsgálata
43 2.15 Karakterláncok vizsgálata reguláris kifejezéssel
kerekítés
keresés és csere
37 2.5 Keresés és csere karakterláncban
kezdőlap
módosítása
kivágás
37 2.6 Karakterlánc részének kivágása
156
kulcs (beállításjegyzékben)
kivonás
45 2.17 Változók összeadása, kivonása
45 2.18 Számkonstansok összeadása, kivonása
konstans
40 2.12 Adatok megadása konstansként
47 2.21 A pi () konstans előhívása a .NET-osztálytárból
könyvtárlista
33 2.1 Könyvtárlista kiíratása
jezésekkel
időrendben
kritikus hiba
kulcs (beállításjegyzékben)
kulcsra
157
LDAP
LDAP
-le
lebegőpontos szám
lemezkezelés
80 3.17 A lemezalrendszer (Disk forrás) eseményeinek kiíratása a rendszernaplóból
letiltott felhasználói fiók
letöltés
levelek keresése
levélszemét
levéltovábbító ügynök
-like
-lt
makecert
mappa
vezett mappába
158
napló
-match
jezésekkel
meghajtó
megjelenítendő név
nevének kiírása
memóriahasználat
mértékegység
52 2.29 Mennyiségek megadása mértékegységgel (KB, MB, GB)
metódus
módosítás ideje
időrendben
Move-Item
mappából
vezett mappába
Move-ItemProperty
kérdezése
napló
159
napok hozzáadása dátumhoz
napok hozzáadása dátumhoz

-ne
négyzetgyök
46 2.20 .NET-függvények hívása számítási műveletekhez; négyzetgyök
nem válaszoló folyamat
.NET-függvény
.NET-osztálytár
47 2.22 Kör sugarának kiszámítása
New-Item
vezett mappába
New-ItemProperty
kérdezése
New-Mailbox
rendszerben
rancselemmel
New-Object
kulcsra
160
összefűzés
-nomatch
objektum
objektumból
mappában
olvasás billentyűzetről
operátor
Out-File
összeadás
összefűzés
161
összehasonlítás
összehasonlítás
parancs futtatása
pénznem
pi ()
pontosság
Pop-Location
postaláda
rendszerben
megjelenítése
PowerShell-szkript
162
return

131 8.1 A PowerShell-szkript futtatásának engedélyezése egy webhely konfi-
gurációjában
Push-Location
Read-Host
rendszerben
reguláris kifejezés
jezésekkel
Remove-Item
mappából
vezett mappába
rendezés
időrendben
rendszernapló
naplóból
return
163
Select-Object
Select-Object
Set-Acl
kulcsra
Set-AuthenticodeSignature
Set-ExecutionPolicy
Set-ItemProperty
kérdezése
módosítása
Set-Location
Sort-Object
időrendben
SQL
164
szavakra bontás
Sqrt
Stop-Process
súgó
87 4.1 Az -Item végű parancselemek kilistázása
számok
52 2.29 Mennyiségek megadása mértékegységgel (KB, MB, GB)
számítás
számrendszer
szavakra bontás
165
százalék
százalék
szóközök eltávolítása
szövegfájl
szűrés
jezésekkel
tábla
tanúsítvány
tanúsítványtár
tartomány
nevének kiírása
területi beállítás
törlés
166
webkiszolgáló
tulajdonság
URL-cím
változó
Visual Basic.NET
Visual C#.NET
visszaadott érték
webhely
131 8.1 A PowerShell-szkript futtatásának engedélyezése egy webhely konfi-
gurációjában
webkiszolgáló
124 6.20 Az IIS webkiszolgáló naplóinak elemzése; annak meghatározása, hogy
melyik IP-címről hány kérés érkezett
167
wget
wget
Where-Object
jezésekkel
mappában
naplóból
while ciklus
WMI
168
B FÜGGELÉK
Szótár
access control list hozzáférés-vezérlő lista

ACL hozzáférés-vezérlő lista
Active Directory A Windows kiszolgálóoldali változatainak címtárszol-
gáltatása. Az ~ nyilvántartja a hálózat különböző objektumait, és a nyilván-
tartást hozzáférhetővé teszi a felhasználók és a rendszergazdák számára. Az
~ ezenkívül a hálózat többi számítógépének erőforrásaihoz is hozzáférést
biztosít a felhasználók számára. Ehhez a felhasználóknak csak egyszer kell
bejelentkezniük a hálózatba.
Active Directory Services Interface  ADSI
Active Server Pages ASP
adatsín (data bus) A számítógépekben az a vezeték a processzor és a memó-
ria között, amelyen keresztül a processzor adatokat ír a memóriába, illetve
olvas a memóriából. Az adatsín fontos jellemzője a szószélesség, amelyet
bitben adnak meg. A korszerű számítógépek ~je 32- vagy 64-bites.
ADSI (Active Directory Services Interface) Az Active Directory alkalma-
zásprogramozói felülete. A PowerShellben is az ~-felületen keresztül tudjuk
irányítani az Active Directory szolgáltatást.
alias álnév
alkalmazás (application) Adott feladat végrehajtására készített program vagy
programok együttese, amely a felhasználó számára egyetlen, egységes esz-
köznek látszik.
alkalmazásprogramozói felület (application programming interface, API) Szol-
gáltatások jól definiált elérési pontjainak együttese, amelyet alkalmazások
használhatnak olyan alacsonyabb szintű műveletek elvégzésére, amelyeket más
programelemek – például az operációs rendszer elemei – valósítanak meg.
állomásnév (host name) a számítógép egyedi neve a gépet tartalmazó tar-
tományon belül.
álnév
álnév (alias) PowerShell-parancs másik, rendszerint rövidebb neve. A dir pa-

rancs például a Get-ChildItem parancselem ~e, és arra szolgál, hogy a
PowerShell felhasználói a könyvtárlistát a régi, ismert paranccsal is kiírat-
hassák.
API  alkalmazásprogramozói felület
application alkalmazás
application programming interface  alkalmazásprogramozói felület
argument argumentum
argumentum (argument) PowerShell-parancselemnek vagy függvénynek meg-
adott adat. Ez jellemzően az az adat, amelyen a parancselem vagy függvény
által meghatározott műveletet végre kell hajtani. Parancselem esetén olyan
adat is lehet, amely befolyásolja a parancselem viselkedését. Sok esetben pa-
raméternek is nevezik.
ASP (Active Server Pages, aktív kiszolgálói oldalak) A Microsoft Internet Informa-
tion Services webkiszolgáló megoldása kiszolgálóoldali programok működ-
tetésére. Az ~ használata esetén a weboldalak HTML-sablonjába Visual
Basic-kód lehet beágyazva, amely az oldal lehívásakor határozza meg, mi le-
gyen az oldalon. Az ~ oldalakat arról ismerjük meg, hogy a böngésző azt jel-
zi, .asp kiterjesztésű fájlt töltött le. Napjainkra az ~ elavult, felváltotta az
ASP.NET.
ASP.NET Az ASP továbbfejlesztése a .NET-koncepciónak megfelelően. Az
~-oldal sablonját XML-ben, illetve XHTML-ben is megfogalmazhatjuk, a prog-
ramkód megírásához pedig bármelyik .NET-alapú programnyelvet használ-
hatjuk (Visual Basic.NET, Visual C#.NET stb.).
ASP.NET-alkalmazás (ASP.NET application) Olyan, webkiszolgálón futó
alkalmazás, amelye az ASP.NET technológiával készült.
assembly language assembly nyelv
assembly nyelv (assembly language) Alacsony szintű programozási nyelv,
amelynek egyes utasításai pontosan megfelelnek a programot futtató pro-
cesszor gépi utasításainak. Minden processzortípusnak más és más az ~e.
Manapság már nem programoznak közvetlenül ~en, mert a programok a ki-
vételkezelés és a többszálúság miatt áttekinthetetlenek lennének.
beállításjegyzék (registry) Olyan tárolóhely a Windows Vistában (és a többi
32-bites Windows operációs rendszerben), ahol a teljes rendszer minden
beállítása megtalálható. A ~ egységes, hierarchikus rendben tárolja az operá-
170
csövezés
ciós rendszer elemei, az illesztőprogramok és a telepített alkalmazások

működéséhez szükséges paramétereket. A ~ a rendszerleíró adatbázis új ma-
gyar neve a Windows Vistában.
beépülő modul (snap-in) Olyan programmodul, amelyet a PowerShellbe kell
betölteni, és amely kiegészíti a PowerShell szolgáltatás- és parancselem-kész-
letét. Ilyen ~lal egészíti ki pl. a PowerShellt a Microsoft Exchange Server
rendszer.
bejelentkezési parancsfájl (logon script) Olyan szkript, amely a felhasználó
bejelentkezésekor automatikusan lefut. Minden felhasználónak külön ~a lehet.
Boolean value Boole-érték
Boole-érték (Boolean value) Olyan adattípus, amelyben egy változónak csak két
értéke (igaz vagy hamis) lehet. A ~ nevét George Boole XIX. századi angol ma-
tematikusról kapta.
certificate tanúsítvány
certificate store tanúsítványtár
ciklus (loop) Program vagy szkript része, amely meghatározott alkalommal
vagy meghatározott feltételek teljesülése esetén ismétlődik.
címtár (directory) Hálózatba kötött számítógépek meghatározott csoportjában
a felhasználók, felhasználócsoportok, kiszolgálók és erőforrások központi
nyilvántartása, amelyre címtárszolgáltatás épül. Az egységes ~ hatásköré-
be eső hálózatrészt a Windows-rendszerekben tartománynak nevezzük.
címtárszolgáltatás (directory service) A címtár mint nyilvántartás vezetése,
illetve azon szolgáltatások együttese, amelyek hozzáférhetővé és használha-
tóvá teszik az adatokat. A ~ lehetővé teszi felhasználók, számítógépek és erő-
források, illetve más objektumok megkeresését (például megtalálja az összes
PostScript-nyomtatót a 3. emeleten). Active Directory, címtár.
cmdlet parancselem
collection gyűjtemény
command prompt parancssor
connection string kapcsolatsztring
csövezés (piping) Olyan parancskiadási, szkriptírási mód a PowerShellben,
amelynek során két vagy több parancsot írunk le úgy, hogy az első parancs
kimenete a második bemenete, a második kimenete a harmadik bemenete és
így tovább. A képernyőre a láncban utolsó parancs kimenete kerül. A ~ so-
rán két parancs közé a | karaktert kell írni.
171
CSV
CSV (comma separated values, vesszővel elválasztott értékek) Szövegfájl-formátum,

amely lehetővé teszi táblázatok leírását egyszerű szövegként. A fájl minden
sora egy táblázatsornak felel meg, sorokon belül pedig vessző, pontosvessző
vagy tabulátor választja el egymástól az adatmezőket. A PowerShellben a
mezőelválasztó karakter a Windows területi beállításaitól függ. Angol beállí-
tás esetén ez a karakter a vessző, magyar beállítás mellett a pontosvessző.
data bus  adatsín
directory címtár
directory service címtárszolgáltatás
domain tartomány
domain controller tartományvezérlő
driver illesztőprogram
edge transport server végponti továbbítókiszolgáló
egész szám (integer) Olyan adattípus, ahol egy változó csak egész értékeket ve-
het fel, törteket nem. ~ a 3, de nem az a 3,5 vagy épp a  (3,1415926535...)
engedély (permission) A biztonsági hozzáférés-szabályozás eszköze a Win-
dowsban. Olyan adat, amely meghatározza, hogy egyes felhasználók milyen
műveletet végezhetnek egy adott objektumon (pl. fájlon).
exception kivétel
exception handling kivételkezelés
Exchange Server A Microsoft e-mail- és közösmunka-kiszolgálója, amely az
Active Directory címtárszolgáltatásra épül.
felhasználói fiók (user account) Olyan elem a Windows biztonsági adatbázi-
sában vagy egy tartomány címtár-adatbázisában, amely minden adatot
tartalmaz a Windows egy felhasználójáról. Ilyen adatok a felhasználó beje-
lentkezési neve és jelszava – ezek a bejelentkezéshez szükségesek –, azon cso-
portok felsorolása, amelyeknek tagja az adott felhasználó, valamint a fel-
használó rendszerszintű hozzáférési jogosultságai és engedélyei. A Windows
XP-ben és a Vistában a helyi ~ok nyilvántartása a Local Users and Groups
(Helyi felhasználók és csoportok) programmal kezelhető. A Windows
kiszolgálóoldali változataival működő tartományvezérlőkön a címtárban
levő ~ok kezelése az Active Directory Users and Computers (Active Direc-
tory – Felhasználók és számítógépek) programmal lehetséges.
felügyeleti konzol (management console) Rendszerfelügyeleti program, amely
az MMC programban működik.
172
Internet Information Services
felügyelt kód (managed code) A .NET-alkalmazásokra jellemző programkód,

amelynek memória- és kivételkezelését a .NET-keretrendszer felügyeli, így
az alkalmazásnak nem kell azzal foglalkoznia, hogy használat után felsza-
badítsa a futáshoz szükséges objektumoknak lefoglalt memóriaterületeket.
folyamat (process) Elemi programmodul működés közben, az általa használt
erőforrásokkal (memóriaterület és annak tartalma) együtt. Az egyes ~ok tar-
tozhatnak az operációs rendszerhez és az alkalmazásokhoz is.
garbage collection szemétgyűjtés
gépi nyelv (machine language) Programozási nyelv, amelynek utasításait a
számítógép processzora fordító- és értelmezőprogram, illetve a .NET-keret-
rendszerhez hasonló programfuttató környezet nélkül, közvetlenül értelmezni
tudja.
gyűjtemény (collection) Olyan adatszerkezet, amely több elemet tartalmaz
(jellemzően) ugyanabból az adattípusból.
host name állomásnév
housekeeping code infrastruktúrakód
hozzáférés-vezérlő lista (access control list, ACL) A Windows biztonsági rend-
szere által használt lista az egyes erőforrások mellett, amely hozzáférés-ve-
zérlő bejegyzésekből áll. A hozzáférés-vezérlő bejegyzése egyetlen felhaszná-
ló vagy felhasználócsoport biztonsági azonosítószámából és azon műveletek
leírásából áll, amelyet a felhasználó vagy csoport elvégezhet az erőforráson.
IIS (Internet Information Services) A Windows webkiszolgáló programja.
illesztőprogram (driver) Olyan program, amely egységes szolgáltató felület
révén (illesztés) az operációs rendszer – és így a programok – számára el-
érhetővé teszi a számítógépben levő hardvereszközöket.
infrastruktúrakód (housekeeping code) Olyan programkód egy alkalmazásban,
amely nem az alkalmazás rendeltetésének megfelelő logikát valósítja meg,
hanem alacsony szintű ütemezési, memóriakezelési és bemeneti–kimeneti
műveleteket. Ha nem felügyelt C vagy C++ nyelven írunk programot, az ~ a
program 90%-át is kiteheti. A .NET-keretrendszer fő előnye, hogy az ~ot ké-
szen kínálja, ezért az alkalmazások kisebbek, emellett gyorsabban és olcsób-
ban megírhatók.
integer egész szám
Internet Information Services IIS
173
intuítív
intuítív (intuitive) Könnyen kitalálható, magától értetődő. Programszolgálta-

tás esetén azt jelenti, hogy az adott szolgáltatást a felhasználók azonnal, ta-
nulás nélkül használni tudják, mert a megjelenéséből könnyű kitalálni, ho-
gyan kell használni.
intuitive intuitív
IP address IP-cím
IP-cím (IP address) A TCP/IP protokollrendszerrel működő hálózatokban,
vagyis gyakorlatilag minden mai hálózatban az ~ a számítógépek egyedi
azonosítója; 32-bites szám, amelyet a leggyakrabban a pontozott tízes for-
mában írunk le. Példa: 192.168.2.78
javítástelepítő (patch installer) Olyan program a Windowsban, amellyel az ope-
rációs rendszer és egyes alkalmazások részeit ki lehet cserélni frissebb, javí-
tott változatra.
junk e-mail levélszemét
kapcsolatsztring (connection string) Olyan, a Windowson belül egységes szer-
kezetű karakterlánc, amelynek segítségével egy program kapcsolódni tud
egy adatbázis-kiszolgálóhoz (pl. SQL Server) vagy más adatforráshoz. A
kapcsolatsztring leírja, hogy az adatforrás milyen jellegű, és hol található.
kiszolgáló (server) Olyan számítógép, amely erőforrásokat tesz hozzáférhe-
tővé más számítógépek számára a hálózaton keresztül. A ~ általában csak a
számítógép szerepe a hálózatban, de a ~ funkciót betöltő számítógépekkel
szemben speciális igények vannak (például másfajta, nagyobb teljesítményű
hardver, másfajta, ezt jobban kihasználó operációs rendszer).
kiszolgálóalkalmazás (server application) Olyan alkalmazás, amely nem köz-
vetlenül a felhasználó számára, hanem más programok számára nyújt szol-
gáltatásokat. Ha például webkiszolgálót telepítünk egy Windows Vista rend-
szerben, az alkalmassá válik webdokumentumok közzétételére, amelyek a
hálózat más számítógépeivel webböngésző segítségével olvashatók el.
kivétel (exception) Hibát jelző esemény egy programban. A ~ hatására a
programkód rendes futása megszakad (felfüggesztődik), és a program egy
másik része – a kivételkezelő kód – kezd futni. A kivételkezelő kód lefutása
után – az eredménytől függően – a program folytatódhat ott, ahol a kivétel
keletkezésekor tartott. A programozás során egy programrészhez úgy tu-
dunk meghatározott kivételkezelő kódot rendelni, hogy a programrészt
elfogóblokkba (try–catch blokkba) zárjuk.
174
logikai érték
kivételkezelés (exception handling) Speciális programkód hozzárendelése

olyan kritikus programrészekhez, amelyek futása során kivétel keletkez-
het. Ha egy programrész futása közben úgy keletkezik kivétel, hogy nincs
megadva kivételkezelő kód, kezeletlen kivételről beszélünk. Ha egy prog-
ramban kezeletlen kivétel keletkezik (tehát valahol elmarad a tudatos és elő-
vigyázatos ~), azt az operációs rendszer általában leállítja.
LDAP canonical form LDAP kanonikus forma
LDAP (Lightweight Directory Access Protocol, kis terhelésű címtár-hozzáférési proto-
koll) Szabványos protokoll, amelynek segítségével a címtárban tárolt
adatok hálózaton keresztül lekérdezhetők a tartományvezérlőkről.
LDAP kanonikus forma (LDAP canonical form) Szabványos leíró formátum
objektumok helyének és nevének megadására – tulajdonképpen az objektum
megcímzésére – az LDAP-protokoll számára. Az ~ban az objektum megadá-
sa belülről kifelé, a legkisebb egységtől a legnagyobb felé halad, éppúgy,
mint a webcímek megadásánál. Előbb megnevezzük magát az objektumot,
majd az objektumot közvetlenül tartalmazó tárolót, majd a tárolót tartalma-
zó tartományt és így tovább. Példa: LDAP://CN=Teszt Elek,CN=Users,DC=teszt,
DC=hu.
levélkiszolgáló (mail server) Kiszolgáló, amely elektronikus leveleket küld
és fogad. A levelezőprogramunk az előre beállított ~val lép kapcsolatba,
amikor e-mailt kell küldenie. A levelek fogadásához pedig a ~n postaládával
kell rendelkeznünk. A levelezőprogramunk a levelek lekérdezésekor a ~n
meglevő postafiókunk tartalmát tölti le. A levélküldés az SMTP-, a levélfo-
gadás és -feldolgozás a POP3- vagy IMAP4-protokollon keresztül történik.
levélszemét (junk e-mail, spam) Olyan e-mail-üzenetek együttese, amelyek rend-
szerint ismeretlen és azonosíthatatlan feladótól érkeznek; kéretlenül küldik
őket. A ~ küldésének jellemző céljai: reklám, a hálózat túlterhelése, károkozás
a címzett számítógépén, illetve a címzett átirányítása hamisított webhelyekre
személyes és pénzügyi adatok illetéktelen megszerzése céljából.
levéltovábbítási ügynök (mail transfer agent) Levélkiszolgáló, különösen
pedig a Microsoft Exchange Server része, amely a levelek más kiszolgáló-
hoz való továbbításáért felel.
log file naplófájl
logging naplózás
logical value logikai érték
logikai érték (logical value) Boole-érték
175
logon script
logon script bejelentkezési parancsfájl

loop ciklus
machine language gépi nyelv
mail server levélkiszolgáló
mail transfer agent levéltovábbító ügynök
managed code felügyelt kód
management console felügyeleti konzol
MMC (Microsoft Management Console) A Windows grafikus felügyeleti prog-
ramja. A különböző felügyeleti műveletek a ~ beépülő moduljaival végezhe-
tők el. Azt a parancsikont, amely meghatározza, hogy a ~ot melyik beépülő
modullal, milyen beállításokkal kell elindítani, felügyeleti konzolnak nevezzük.
mnemonic mnemonik
mnemonik (mnemonic) Emlékeztető jelölés, amelyet az assembly nyelvek, az
operációs rendszerek parancsnyelvei, illetve egyes programozási nyelvek al-
kalmaznak. Az assembly nyelvek a processzor gépi nyelvéhez rendelnek 2-4
betűs emlékeztető szócskákat. Az operációs rendszerek parancsnyelveiben a
~ok a rendszerben végezhető műveletekre utalnak, anélkül hogy teljes angol
szavakat vagy mondatokat kellene írni. (Példa: a Unix-rendszerekben az ls, a
Windowsban a dir parancs listázza ki az aktuális könyvtár tartalmát.) A
PowerShell intuitív parancsmegadást alkalmaz: minden parancselem egy
igéből és egy főnévből áll. Ezek rövidítésére azonban bevezethetünk mne-
monikus álneveket.
multithreaded többszálú
naplófájl (log file) Olyan szövegfájl, amelybe egy program feljegyzi a műkö-
désével kapcsolatos legfontosabb eseményeket, jellemzően figyelmeztetése-
ket és hibákat. Valahányszor érdekes esemény történik, a program új be-
jegyzést ír a fájl végére.
naplózás (logging) Az a tevékenység, amelynek során az operációs rendszer
és egyes programok folyamatosan feljegyzéseket készítenek a működésük-
kel kapcsolatos fontosabb eseményekről, hogy a rendszergazda üzemzavar
esetén rendelkezzen olyan információval, amely az üzemzavar okának ki-
alakulásakor keletkezett.
natív kód (native code) Olyan programkód, amelyet a számítógép program-
futtató környezet (pl. a .NET-keretrendszer) közreműködése nélkül futtat.
native code natív kód
176
önaláírt tanúsítvány
.NET Framework .NET-keretrendszer

.NET-keretrendszer (.NET Framework) A Microsoft által kifejlesztett program-
futtató környezet komponensalapú webes és grafikus alkalmazások gyors fej-
lesztéséhez és működtetéséhez. A PowerShell használatához a 2.0 vagy
újabb változat szükséges.
nyílt forráskód (open source) Olyan programterjesztési elv és mozgalom,
ahol a programokhoz mindig mellékelik a forráskódot, amelyet a felhaszná-
ló visszafejthet, javíthat, saját munkáiban felhasználhat és tovább is adhat.
object-oriented programming objektumorientált programozás
objektumorientált programozás (object-oriented programming) Olyan progra-
mozási elv, amely a világot kategóriákba soroló emberi gondolkodást követi.
Az ~ során elsősorban nem a program eljárását (a műveletek sorrendjét) ír-
ják le, hanem kialakítanak egy rendszert – modellt – a program által kezelt
objektumokból, és leírják, hogy az egyes objektumokkal mi történhet, illetve
az objektumok hogyan vannak egymásra hatással.
open source nyílt forráskód
operációs rendszer (operating system) Olyan program, amely biztosítja a szá-
mítógép erőforrásainak szolgáltatásait az alkalmazások számára, anélkül
hogy azoknak közvetlenül kezelniük kellene az erőforrásokat, illetve a hard-
ver elemeit. Az ~ egyúttal felügyeli is a programok futását: gondoskodik az
erőforrások megfelelő megosztásáról (például szabályozza, hogy az egyes
programok milyen ütemezésben jutnak processzoridőhöz), és nyilván is tart-
ja az egyes programok által használt erőforrásokat. Az ~be általában fel-
használói szolgáltatásokat – parancssort, grafikus felhasználói felületet és se-
gédprogramokat – is beleértenek.
operating system operációs rendszer
operator operátor
operátor (operator) Műveleti jel; programozási nyelv olyan eleme, amely egy
vagy több adaton végzendő egyszerű műveletet ír elő. A PowerShell-ben
például a –gt operátorral vizsgáljuk, hogy egy szám nagyobb-e egy másik-
nál: $a –gt $b.
önaláírt tanúsítvány (self-signed certificate) Olyan tanúsítvány, amelynek
hitelességét maga a tanúsítvány létrehozója tanúsítja aláírásával. Ez azt je-
lenti, hogy a tanúsítvány kibocsátója csak nyilatkozik a saját azonosságáról;
az ~ok esetén a tanúsítvány kiadójának azonosságát nem igazolja harmadik
fél. Az ~ok egy cégen belül megfelelőek például PowerShell-szkriptek alá-
177
parancselem
írására, az e-kereskedelemben vagy az elektronikus ügyintézésben viszont

csak a harmadik fél (gyökérszintű hitelesítésszolgáltató) által aláírt tanúsít-
ványokat fogadhatjuk el megbízhatónak.
parancselem (commandlet, cmdlet) A PowerShellben a legkisebb, önállóan vég-
rehajtható parancs. Egy parancs több ~ből is állhat, amelyek a csövezés útján
vannak összekötve egymással. Egy ~ egy konkrét műveletet ír elő egy konk-
rét objektumon. Ennek megfelelően minden ~ neve egy igéből és egy főnév-
ből áll. Példa: Get-ChildItem.
parancsfájl (script) szkript
parancssor (command prompt) Olyan program, amely egy ablakban lehetővé
teszi parancsok begépélését, és azokra ugyanabban az ablakban ad választ.
A PowerShell is ~.
patch installer javítástelepítő
Perl (Practical Extraction and Report Language, gyakorlati kivonatoló és jelentéské-
szítő nyelv) Általános célú szkriptnyelv (tulajdonképpen programozási nyelv),
amely elsősorban a Unix-környezetekben terjedt el. A ~ fő alkalmazási terü-
letei: szövegfeldolgozás és webhely-programozás. A ~ a hagyományos CGI-
alkalmazások fő programozási nyelve volt.
permission engedély
piping csövezés
process folyamat
protocol protokoll
protokoll (protocol) Számítógép-hálózatokban a számítógépek közötti kom-
munikáció kezdeményezéséhez, fenntartásához, illetve bontásához szüksé-
ges, kötött szintaktikai és szemantikai szabályok összessége.
registry beállításjegyzék
rendszerfelügyelet (systems management) Az a tevékenység, amelynek során
a rendszergazda figyeli egy számítógépes rendszer és hálózat működését, és
probléma esetén közbeavatkozik: például új rendszerelemeket telepít, fájlo-
kat helyez máshova vagy változtat a beállításokon. A ~ lehet megelőző jelle-
gű is, ide tartozik például a biztonsági frissítések telepítése vagy a víruskere-
ső rendszer frissítése.
rendszerhéj (shell) Olyan program, amelynek elsődleges célja a felhasználó
és az operációs rendszer közötti kommunikáció biztosítása. Minden parancs-
sor egyben ~ is, de ~ a Windows grafikus felhasználói felülete is.
178
szervizcsomag
SCL (Spam Confidence Level, levélszemét-valószínűségi szint) Olyan szám, amelyet

a levélszemét-szűrő program rendel a bejövő e-mail-üzenetekhez. A szám
azt jelzi, hogy az adott üzenet milyen valószínűséggel levélszemét.
script szkript
self-signed certificate önaláírt tanúsítvány
server kiszolgáló
server application kiszolgálóalkalmazás
service pack szervizcsomag
shell rendszerhéj
SMTP server SMTP-kiszolgáló
SMTP-kiszolgáló (SMTP server) Olyan levélkiszolgáló, amely az SMTP-pro-
tokoll segítségével leveleket fogad a felhasználók levelezőprogramjaitól, il-
letve továbbít más ~khoz. Az SMTP (Simple Mail Transfer Protocol, egyszerű
levéltovábbítási protokoll) az internet egyeduralkodó levéltovábbítási pro-
tokollja.
snap-in beépülő modul
spam  levélszemét
SQL (Structured Query Language, strukturált lekérdezőnyelv) Olyan speciális cé-
lú programozási nyelv, amelyet adatbázisok lekérdezésére és módosítására
használnak. Az ~ napjainkra az adatbázis-kezelés egyeduralkodó nyelve lett;
használják olyan adathalmazokra is, amelyek szigorúan véve nem tekinthe-
tők adatbázisnak.
systems administration rendszerfelügyelet
systems management rendszerfelügyelet
szemétgyűjtés (garbage collection) Az a folyamat, amelynek során az operáci-
ós rendszer megkeresi és felszabadítja azokat a memóriaterületeket, amelye-
ket a futó programok már nem használnak. A ~ a futtató környezet – pl. a
.NET-keretrendszer – szolgáltatása, és csak a felügyelt kódban írt programok
számára áll rendelkezésre. Ha valaki natív C vagy C++ nyelven ír progra-
mot, a már nem használt memóriaterületek felszabadításáról magának kell
gondoskodnia. Felügyelt C++, C# vagy Visual Basic.NET esetén ezt a .NET-
keretrendszer végzi.
szervizcsomag (service pack) A Microsoft operációs rendszereihez és más
kiszolgáló alkalmazásaihoz időnként megjelenő csomag, amelynek telepíté-
179
szkript
sével a rendszer bizonyos hibái javíthatók. Egyes ~ok új szolgáltatásokat is

hozzáadnak az operációs rendszerhez. A ~okhoz a felhasználók – ha az
adott rendszer jogosult felhasználói – ingyen juthatnak hozzá.
szkript (script) Olyan program, amely elsősorban parancsok sorozata, és va-
lamilyen szkriptnyelven van megírva. A ~eket mindig értelmezőprogram
hajtja végre, vagyis nem fordítják le őket se gépi nyelvre, se köztes kódra. A
~ekre jellemző még, hogy a programvezérlő szerkezeteket (elágazások, cik-
lusok, függvények, objektumok) csak korlátozottan használhatják.
tanúsítvány (certificate) Olyan adatstruktúra, amely kevéssé biztonságos há-
lózatokban (pl. az interneten) megfelelő hitelesítést és biztonságos adatcserét
tesz lehetővé. A ~ok nyilvános titkosítási kulcsot rendelnek ahhoz a sze-
mélyhez vagy szervezethez, akinek vagy amelynek a megfelelő titkos kulcs a
birtokában van. A ~ok tartalmazzák az őket kiadó hitelesítésszolgáltató digi-
tális aláírását is. Felhasználók, számítógépek vagy szolgáltatások hitelesíté-
sére, programok és adatok digitális aláírására használhatók.
tanúsítványtár (certificate store) Védett tárolóhely a merevlemezen, ahol az
operációs rendszer a felhasználó által különböző célokra használt tanúsítvá-
nyokat tárolja.
tartomány (domain) Az Active Directory címtárszolgáltatással megvaló-
sított, központi címtáradatbázissal és biztonsági rendszerrel rendelkező he-
lyi hálózat vagy hálózatrész.
tartományvezérlő (domain controller) A tartomány címtár-adatbázisát tá-
roló számítógép. A ~ a rajta tárolt címtár-adatbázis alapján címtárszolgálta-
tást is nyújt, vagyis nyilvántartja és bejelentkezteti a felhasználókat, elvezeti
őket a címtárban közzétett erőforrásokhoz, és biztosítja a tartomány számí-
tógépeinek központi felügyeletét.
többszálú (multithreaded) Program jellemzője: a ~ program egy időben több
lépéssort is el tud végezni egymástól függetlenül. A ~ program egy folya-
mat; a különálló utasításszálak közös adatterületet használnak.
user account felhasználói fiók
változó (variable) A programozási nyelvekben a ~ olyan szimbólum, amely
egy meghatározott memóriaterületre hivatkozik, és meghatározott típusú
adatot tartalmaz. A változónak a program írója ad nevet, és a programutasí-
tásokban ezt a nevet használhatja a memóriaterület címe vagy az ott tárolt
érték helyett.
variable változó
180
WMI
végponti továbbítókiszolgáló (edge transport server) Olyan levéltovábbító

ügynök az Exchange Server rendszerben, amely az aktuális tartományon
kívülre továbbít leveleket.
vesszővel elválasztott értékek CSV
Web server webkiszolgáló
webkiszolgáló (Web server) Olyan kiszolgáló, amely hierarchikus könyv-
társtruktúrában dokumentumokat szolgáltat a helyi hálózat vagy az internet
számítógépei számára. A ~ról a HTTP nevű protokoll szabályai szerint
megfogalmazott kérésekkel lehet a dokumentumokat letölteni: erre a web-
böngésző programok használhatók.
Windows-tartomány tartomány
WMI (Windows Management Instrumentation; Windowsbeli felügyeleti műszerezés)
Alkalmazásprogramozói felület (API) a Windowsban, amelyen keresztül a
számítógép-rendszer részegységei szabványos eljárással elérhetők, beállítá-
saik lekérdezhetők és megváltoztathatók. A ~ a DTMF (Desktop Manage-
ment Task Force; munkacsoport asztali rendszerek felügyeleté[nek tervezé-
sére]) nevű szervezet WBEM (Web-based Enterprise Management; webala-
pú vállalati rendszerfelügyelet) specifikációjára épül.
181
C FÜGGELÉK
Felhasznált és ajánlott
irodalom
Albert István (szerk.): A .NET Framework és programozása. Alkalma-

zott Informatika sorozat. SZAK Kiadó, Bicske, 2004.
Benedek Zoltán, Levendovszky Tihamér: Szoftverfejlesztés C++ nyel-

ven. Alkalmazott Informatika sorozat. SZAK Kiadó, Bicske, 2007.
A. Kingsley-Hughes, K. Kingsley-Hughes: Kezdőkönyv a programozás-

ról. SZAK Kiadó, Bicske, 2007.
Kis Balázs, Szalay Márton: Windows Vista haladókönyv. SZAK Kiadó,

Bicske, 2007.
Michael McMillan: Perl (1. rész). Panem Könyvkiadó, Budapest, 1998.
David S. Platt: Bemutatkozik a Microsoft .NET. SZAK Kiadó, Bicske,

2003.
William R. Stanek: Microsoft Exchange Server 2007 – A rendszergazda

zsebkönyve. SZAK Kiadó, Bicske, 2008.
William R. Stanek: Microsoft Windows parancssor - A rendszergazda

zsebkönyve. SZAK Kiadó, Bicske, 2005.
William R. Stanek: Windows Server 2008 – A rendszergazda zsebkönyve.

SZAK Kiadó, Bicske, 2008.
Julian Templeman, Andy Olsen: Microsoft Visual C++ .NET Step by

Step. Microsoft Press, Redmond, 2003.
Felhasznált és ajánlott irodalom
Internetes források
Windows PowerShell Owner’s Manual:

http://www.microsoft.com/technet/scriptcenter/topics/winpsh/manual/
default.mspx
MSDN Library:
http://msdn.microsoft.com/hu-hu/library/default(en-us).aspx
A könyv saját honlapja: http://www.powershellkonyv.hu
184
Tárgymutató
16-os számrendszer, 64, 65, 141, 147, aktuális mappa, 142

154, 156, 165 aláírás, 83, 86, 143
8.3-as formátum, 134 alapértelmezett beállítás, 82
ábécésorrend, 141 alias, 32
AcceptMessage, 130 Alkalmazás, 79, 121
access control entry, 94 alkalmazásprogramozói felület, 105
access control list, 94 alkönyvtár, 143
ACL, 94 AllSigned, 82, 85
Active Directory – felhasználók és szá- álnév, 32
mítógépek, 10 -and, 41, 80, 81, 120
Active Directory Services Interface, 109 Append, 62
Active Directory Users and Computers, AppendData, 96
10, 113 Application log, 119
Active Directory, 10, 29, 107–115, 118, Application, 79, 119
126, 141, 142, 144, 145, 148, 149, 155, argumentum, 30
156, 158, 159, 161, 166 aritmetikai művelet, 45, 143, 157, 165
Active Directory-tartomány, 107, 110, ASP, 21, 133, 136
114, 142, 145, 148, 149, 159, 166 ASP.NET, 21, 133, 136
adatmező, 142 ASP.NET-alkalmazás, 133, 136
adatsín, 108 –AsSecureString, 127
AddAccessRule, 95, 102 assembly nyelv, 32
AddDays, 76, 77, 80, 81, 119, 120, 131 áthelyezés, 143
AddHours, 77 átlagszámítás, 143
AddMilliSeconds, 77 AutoSize, 61, 106, 130
AddMinutes, 77 bájt, 14
AddMonths, 77 -band, 41
Add-PSSnapin, 126, 131, 142 bash, 10, 13
AddSeconds, 77 beállításjegyzék, 34, 97–103, 123, 134, 143,
AddTicks, 77 146, 150, 151, 153–155, 157, 160, 164
AddYears, 77 Beállításszerkesztő, 97
Administration Tools Pack, 114 beépülő modul, 125, 126, 134, 143
ADSI, 109, 112–115, 118, 141, 148, 158 Beillesztés, 71
ADSI-felület, 109, 141, 148, 158 bejelentkezési parancsfájl, 86, 102
aktuális dátum és idő, 24, 35, 142, 145, Benne van, 44
152, 155, 167 billentyűzet, 143
aktuális dátum, 24, 35, 67, 76, 77, 88–90, Bitenkénti ÉS, 41
123, 142, 145, 147, 152, 155, 158–161, Bitenkénti VAGY, 41
163, 167 Biztonság, 79
Tárgymutató
biztonságos karakterlánc, 127, 143 csoportosítás, 144

Boole, 44, 73 csoporttagság, 144
-bor, 41 csv, 62, 92–95, 118, 127, 131
böngésző típusa, 143 CSV-fájl beolvasása, 93, 144, 147, 153
Builtin, 110 CSV-fájl, 93, 118, 127, 142, 144–148, 153–
C#, 17, 22, 24, 106, 137, 139, 144 155, 159–161, 168
cd, 11, 32, 84, 99 DateTime, 24, 25, 34, 67, 73, 76
Cert:, 84, 144 dátum, 15, 24, 25, 66, 67, 76, 142, 145,
ChangePermissions, 96, 103 147, 152, 155, 161
ciklusváltozó, 49, 144, 149 dátumok kivonása, 145
címtár, 108, 110 Debug, 30, 139
címtárszolgáltatás, 109 Default, 82, 137, 139
class, 17 del, 12
Clear-Host, 32 Delete, 96, 103, 114, 128
Clear-Item, 87, 88, 100 DeleteSubdirectoriesAndFiles, 96
Clear-ItemProperty, 100 digitális aláírás, 82
CLI, 10 dir, 11, 29–32, 84, 99, 145
cls, 32 DirectoryInfo, 33
cmd.exe, 12 Disk, 80, 146, 152, 158, 163, 168
cmdlet, 29 displayName, 110, 111, 113, 114, 118
collection, 24 DNS-név, 134
comma separated values, 62 Domain Context, 110
Command Line Interface, 10 Domain Users, 112, 141, 144, 148
Command Prompt, 10 dsadd, 114
commandlet, 29 dsget, 114
Common Language Runtime, 22 dsmod, 114
Common Name, 110 dsmove, 114
Compare-Object, 58, 59, 144 dsquery, 29, 114, 115, 145
ComputerName, 122 dsrm, 114
Computers, 110 Edit, 71
Confirm, 31 egész szám, 14, 18, 24, 25, 41, 117
connection string, 116 egyelés, 145
-contains, 41, 42, 44, 144 egységbezárás, 17
copy, 12, 31 e-mail küldése, 120, 145, 146, 152, 157, 160
Copy-Item, 32, 87, 88, 90, 100 e-mail, 25, 109, 119, 120, 129–132, 142,
Copy-ItemProperty, 100 145, 146, 150–152, 157, 158, 160
Count, 25, 57 e-mail-cím, 120, 130, 145, 146, 150, 151,
CreateDirectories, 96 158
CreateEventSource, 119 e-mail-forgalom, 131, 132, 142, 145, 146,
CreateFiles, 96 151, 158, 161
CreateSubKey, 103 Enable-Mailbox, 126
CreationTime, 34, 60 encapsulation, 17
csoport, 94, 95, 103, 111, 144 EndsWith, 36, 38, 54
csoportok elemeinek megszámolása, 58, engedély, 95, 96, 104, 146, 147, 151, 154,
144, 149, 151, 153, 154, 157 160, 164
186
Tárgymutató
engedélyek, 94, 102 fizikai memória, 73, 106, 108, 148, 150,
EntryType, 80, 81, 120, 122 153, 158, 168
EnumerateSubKeys, 103 fizikai merevlemez, 107
-eq, 40, 80, 81, 88, 90, 101, 102, 120, 131, FolderAndSubfolderSize, 129
146 FolderPath, 129
Error, 14, 119 folyamat, 59, 72–74, 148, 153, 159, 164,
ErrorAction, 31 165, 168
ErrorVariable, 31 folyamatlista, 149
érték visszaadása, 69, 150, 163, 167 folyamatok, 59, 72–74, 108, 134, 136,
eseménynapló, 79, 119, 120, 146 137, 139, 144, 148, 149, 153, 154, 159,
EventLogEntryType, 119 162, 164, 167
Exchange Server 2007, 9, 125, 126, 128 for ciklus, 48, 49, 70, 71, 144, 149, 167
Exchange Server, 9, 125, 126, 128, 146, for, 48, 49, 70–72, 85, 107, 127, 144, 149,
148, 160, 162 167
Exchange-kiszolgáló, 129 ForEach-Object, 53, 54, 58, 59, 64, 88,
Exchange-postaláda, 129, 146, 153, 162, 90–92, 114, 115, 118–120, 122, 124, 127,
164 149
ExecuteFile, 96 Format parancselem, 60
ExecuteKey, 103 Format-List, 60, 61, 106, 149
Export parancselem, 62 Format-Statistics, 149
Export-Clixml, 62 Format-Table, 60, 61, 106, 128–130, 150
Export-Csv, 62, 94 formázás, 150
-f operátor, 63, 64, 67, 142, 147, 149–151, formázósablon, 150
156, 157, 161 FullControl, 95, 96, 102
fájl beolvasása, 147 function, 69–71, 99, 150
fájl, 13, 14, 21, 22, 28, 30, 56–58, 62, 82, Futtatás rendszergazdaként, 83
88, 91–93, 126, 132, 137, 142, 143, 147, futtatás, 150
149, 151, 157, 159, 163, 164, 166 futtatási házirend, 82, 83, 85
fájlkiterjesztés, 147 függvény, 69–71, 150, 156, 160, 166
fájlok áthelyezése, 88, 90, 142, 143, 147, garbage collection, 23
149, 151, 158–160, 163, 166 GB, 52, 159, 165
fájlok és mappák törlése, 96 gd, 32
fájlrendszer, 58, 87, 94 -ge, 40, 41, 49, 70–72, 150
false, 73, 111, 114, 118, 137 gépi nyelv, 32
felbontás, 107 Get-Acl, 94, 95, 102, 151
felhasználói fiók létrehozása, 148 Get-AgentLog, 130, 131, 151
felhasználói fiók törlése, 114, 141, 148 Get-Alias, 32
felhasználói fiók, 10, 95, 103, 109–115, Get-ChildItem, 32, 33, 39, 51–58, 60–62,
126, 134, 141, 142, 144–146, 148, 149, 64, 77, 84, 85, 88, 90, 92, 94, 98, 99, 119,
156, 158–163, 166 122, 124, 151
feltételvizsgálat, 44 Get-Clipboard, 134
felügyeleti konzol, 109 Get-Command, 32
felügyelt kód, 22 Get-Content, 91, 92, 124, 152
FileSystemAccessRule, 95, 96, 102 Get-Date, 32, 35, 66, 67, 76–78, 80, 81,
fizikai cím, 107 89, 119, 120, 122, 130, 131, 152
187
Tárgymutató
Get-EventLog, 79–81, 120, 122, 152 if operátor, 44, 144, 155, 156, 161
Get-Help, 32, 87, 126, 153 if, 44, 88–90, 101, 102, 107, 112, 119, 124,
Get-Item, 87, 88, 100–102, 122, 153 131, 144, 155, 156, 161
Get-ItemProperty, 100–102, 122, 153 igény szerinti fordító, 23
Get-Mailbox, 128, 129, 153 IIS, 21, 123, 124, 143, 152–156, 159, 167
Get-MailboxFolderStatistics, 128, 129, 153 Import-Csv, 92, 93, 118, 127, 155
Get-Member, 33, 36, 61, 73, 76, 81, 93, Information, 80, 81, 119
111, 153 infrastruktúrakód, 21
Get-Process, 59, 72–75, 136, 138, 139, 153 inheritance, 17
Get-PSDrive, 34, 84 InputObject, 59
Get-Random, 134 INSERT, 117, 122
Get-Shortpath, 134 instance, 17
Get-WmiObject, 106, 107, 153 instantiation, 18
givenName, 110, 111, 113, 118 integer, 14, 18, 24
grafikus felület, 10, 109, 134 Internet Explorer, 101, 102, 143, 153,
grep, 13 155, 156, 164
Group-Object, 57–59, 124, 153 Internet Information Services, 21
-gt, 40, 80, 81, 107, 120, 122, 131, 154 internet, 130
GZIP algoritmus, 134 Invoke-Expression, 91, 92, 155
gyorsítótár, 108 Invoke-Item, 87
Gyökértanúsítvány, 84, 154, 158, 162, 166 InvokeSet, 111, 114, 118
gyűjtemény, 24, 34, 38, 39, 52, 53, 57, 59, IP-cím, 70, 71, 107, 120, 124, 131, 134,
94, 123, 144, 147–149, 151, 153, 154, 150, 152, 153, 155, 156, 159, 167
156, 157, 159, 162, 165, 166, 168 ismétlődő elemek kihagyása, 156
hálózati csatoló, 107 -Item, 87, 90, 101, 153, 165
HasExited, 73 ItemProperty, 100
hátul tesztelő while ciklus, 50, 143, 154, jelszó, 113, 156
160, 161, 163, 165, 168 JIT, 23
help, 32, 85 jobbra zárás, 156
helyettesítő karakterek, 41 just-in-time, 23
hexadecimális, 65, 154 karakterlánc, 14, 24, 33, 36–38, 42, 44,
HKCU, 97 54, 70, 91, 93, 110, 116, 123, 127, 143,
HKEY_CURRENT_USER, 97, 99 156, 160
HKEY_LOCAL_MACHINE, 97, 123 KB, 52, 159, 165
HKLM, 97–99, 122 képernyő-beállítás, 107
hostname, 121 kerekítés, 156
hozzáférési engedély, 102, 143, 146, 151, keresés és csere, 156
154, 157, 160, 164 kezdőlap, 156
hozzáférés-vezérlő bejegyzés, 94, 95, 103 kimenet, 12, 33, 59, 61
hozzárendelt betűjel, 108 kiszolgáló, 9, 115–117, 122, 130
HTML, 21 Kiszolgálókezelő, 29
ICMP-csomag, 134 kiterjesztés, 13, 84
idő, 13, 16, 35, 66, 67, 73, 76, 97, 142, 145, kivágás, 156
147, 152, 155, 157, 161 kivételkezelés, 23
időtartam, 73, 78, 145, 152, 155 kivonás, 157
188
Tárgymutató
konfigurációs fájl, 82 md, 11, 31, 99

konstans, 47, 157, 160, 162, 165 meghajtó, 12, 77, 84, 97, 98, 101, 144,
könyvtárlista, 39, 55, 56, 60, 61, 141, 149– 145, 159, 166
151, 154, 155, 157, 159, 163, 164, 167 megjelenítendő név, 111, 159
kötet, 14 memóriahasználat, 159
köztes nyelv, 22 merevlemez, 105
kritikus hiba, 157 mértékegység, 159
kulcs (beállításjegyzékben), 157 metódus, 46, 159
kulcs, 100–103, 123, 157 Microsoft ForeFront Threat Manage-
LastAccessTime, 61, 77, 119 ment Gateway, 125
LastWriteTime, 11, 33, 34, 39, 51, 55–57, Microsoft System Center Data
61, 77, 92 Protection Manager 2007, 125
LDAP, 109, 110, 112–115, 118, 158 MMC, 10, 109
-le, 40, 48, 49, 117, 158 mmc.exe, 12
lebegőpontos szám, 24, 158 mnemonik, 32
lemezalrendszer, 80, 146, 152, 158, 163, Modify, 96
168 módosítás ideje, 55, 56, 151, 155, 157,
lemezkezelés, 158 159, 163
Length, 11, 33, 36–39, 51, 53–57, 64, 70– Monad Shell, 81
72, 77, 92, 127 Move-Item, 87, 88, 90, 100, 159
letiltott felhasználói fiók, 113, 158 Move-ItemProperty, 100, 159
letöltés, 28, 158 MSDN, 47, 77, 92, 106
levelek keresése, 158 nagyobb vagy egyenlő, 70
levélkiszolgáló, 120 Name, 11, 14, 30, 33, 34, 36, 39, 51, 53–
levélszemét, 130, 131, 142, 145, 146, 151, 58, 60, 61, 64, 77, 87, 92, 93, 99, 100,
158, 161 102, 107, 122, 128
levéltovábbító ügynök, 130, 145, 146, napló, 79, 121, 123, 159
150, 151, 158 naplóadatbázis, 121
Lightweight Directory Access Protocol, naplógyűjtő kiszolgáló, 120
109 naplózás, 96, 103
-like, 41, 42, 131, 158 naplózási szabály, 96, 103
ListDirectory, 96 napok hozzáadása dátumhoz, 160
log server, 120 natív kód, 23
logikai érték, 41, 44 natív, 23, 114
logon script, 86 -ne, 36, 50, 106, 117, 131, 160
ls, 13 négyzetgyök, 46, 160, 165
-lt, 40, 41, 77, 89, 90, 119, 127, 131, 158 nem válaszoló folyamat, 75, 148, 153,
makecert, 84, 158 160, 168
MakeCert.exe, 83 New-Item, 32, 87, 88, 90, 99, 100, 160
managed code, 22 New-ItemProperty, 100, 160
mappa, 56, 57, 76, 84, 86, 88, 90, 96, 129, New-Mailbox, 126, 127, 145, 146, 148,
158 155, 160
-match, 40, 42, 43, 53, 93, 130, 159 New-Object, 95, 102, 115, 120, 122, 127, 160
MB, 51, 52, 73, 74, 148, 153, 159, 164, New-Shortcut, 134
165, 168 -nomatch, 161
189
Tárgymutató
-not, 40, 41, 112, 124 pénznem, 65, 147, 162, 165
-notcontains, 41 Perl, 35
notepad, 59 physicalDeliveryOfficeName, 111, 113,
notepad.exe, 59 118
Notify, 103 pi, 46, 47, 157, 160, 162, 165
-notlike, 41 Ping-Host, 134
-notmatch, 40, 112 pipe, 12, 71
nyílt forráskód, 133 piping, 12
Object, 36, 51, 59, 93, 131 polymorphism, 17
objektum törlése, 96, 103 pontos idő, 66, 142, 145, 147, 152, 155,
objektum, 18, 24, 25, 33, 41, 52, 58, 70, 76, 161
96, 103, 104, 109, 111, 113, 116, 120, 161 pontosság, 162
objektumorientált programozás, 15 Pop-Location, 90, 91, 142, 158, 162
olvasás billentyűzetről, 161 postaláda, 126, 129, 146, 148, 160, 162
operációs rendszer, 9, 13, 14, 20–22, 24, PowerGUI, 134
28, 29, 62, 65, 79, 83, 84, 105, 107 PowerShell Analyzer, 135
operátor, 44, 64, 65, 161 PowerShell Community Extensions, 133
-or, 41 PowerShell-szkript, 84, 85, 125, 137, 143,
órajel, 108 154, 158, 162–164, 166
Organizational Unit, 110 Process, 72, 73, 75
osztály, 17–20, 46, 47, 102, 106, 119 ProcessName, 72–75, 138
OU, 110, 118, 127 processzor, 73, 107
Out parancselem, 61 programfuttató környezet, 21
OutBuffer, 31 Push-Location, 90, 91, 142, 158, 162
Out-File, 62, 131, 161 QueryValues, 103
Out-Host, 62 rd, 12, 127
Out-Printer, 62 Read, 50, 51, 62, 96, 116, 126, 127, 163
OutVariable, 31 ReadAndExecute, 96
önaláírt tanúsítvány, 83 ReadAttributes, 96
öröklődés, 17 ReadData, 96
összeadás, 46, 53, 161 ReadExtendedAttributes, 96
összefűzés, 161 Read-Host, 50, 51, 62, 126, 127, 163
összehasonlítás, 162 ReadKey, 103
PagedMemorySize, 73 ReadPermissions, 96, 103
parancs futtatása, 91, 92, 150, 151, 155, Registry Editor, 97
156, 162, 167 registry, 97
parancselem, 29–32, 34, 50, 52, 53, 55, RegistryAccessRule, 102
57, 58, 61, 73, 77, 79, 81, 88, 90–92, 94, reguláris kifejezés, 40, 42–44, 52, 53, 143,
98, 100, 106, 129, 130, 134 151, 156, 157, 159, 161–163, 166, 168
parancsfájl, 120 RejectMessage, 130
parancsikon, 134 Remote Server Administration Tools, 114
parancssor, 9, 12, 15, 33, 46, 59, 95 RemoteSigned, 82
parancssori felület, 10 Remove, 30, 36, 77, 87, 88, 90, 99, 100,
Paste, 71 112, 163
példány, 17, 28, 81 Remove-Item, 77, 87, 88, 90, 99, 100, 163
190
Tárgymutató
Remove-ItemProperty, 100 SmtpClient, 120

ren, 12 SMTP-kiszolgáló, 120
Rename-Item, 87, 88, 99 SMTP-protokoll, 134
Rename-ItemProperty, 100 snap-in, 126
rendezés, 163 sorozatszám, 108
Rendszer, 121 Sort-Object, 55, 56, 73–75, 122, 129, 164
rendszerfelügyelet, 69, 105, 108 Source, 79–81, 120, 122
rendszerhéj, 9 spam, 130
rendszerindítás, 107 Split, 37, 38, 70, 71, 124
Rendszernapló, 79 SQL, 105, 115–117, 121–123, 146, 152,
Replace, 37, 38, 41, 114, 115, 122 154, 160, 164, 166
-replace, 41 SQL-adatbázis, 115, 122, 146, 152, 154,
Replace, 69 160, 164, 166
Resolve-Host, 134 SqlCommand, 115, 116, 122
Responding, 73, 75 SqlConnection, 115, 116, 122
Restricted, 82 Sqrt, 46, 165
return, 69–72, 163 Start Debugging, 139
Run As Administrator, 83 Start, 11, 29, 101, 102, 139
saját tulajdonba vétel, 96, 104 StartTime, 73
sc, 29 Stop-Process, 29, 72, 74, 75, 165
SCL, 131 Stop-Service, 29
SCL-érték, 131 string, 24, 41
script, 10, 85 Substring, 37, 38, 70
SecureString, 127 súgó, 165
Security, 79, 85, 95, 102, 115, 116, 122, 127 System, 33, 36, 37, 46, 47, 59, 67, 73, 79–
Select-Object, 56, 57, 59, 81, 129, 164 81, 93, 95, 102, 115, 119–122, 127, 137
Send-SmtpMail, 134 System.Diagnostics.Process, 59, 73
Server Manager, 29 System.Math, 46, 47, 67
server, 137, 139 szabad memória, 107
Set, 14, 30, 32, 82–85, 87, 88, 90, 91, 94, számítás, 165
95, 98–103, 122, 134, 164 számítási művelet, 46, 160, 165
Set-Acl, 94, 95, 102, 103, 164 számok, 67, 147, 156, 158, 162, 165
Set-Alias, 32 számológép, 45
Set-AuthenticodeSignature, 85, 164 számrendszer, 165
Set-Clipboard, 134 szavakra bontás, 165
Set-ExecutionPolicy, 82, 83, 85, 164 százalék, 166
SetInfo, 110, 111, 113–115, 118 szemétgyűjtés, 23
Set-Item, 87, 88, 100, 102, 122, 164 szervizcsomag, 27, 107
Set-ItemProperty, 100, 102, 122, 164 szkript, 14, 82, 85, 86, 88, 89, 114, 118,
Set-Location, 32, 84, 85, 90, 91, 98, 99, 123, 124, 132
101, 164 szóköz, 38, 43
SetValue, 104 szóközök eltávolítása, 166
shell, 10 szövegfájl, 166
shutdown, 30 szűrés, 166
SideIndicator, 59 tábla, 115, 166
191
Tárgymutató
TakeOwnership, 96, 104 Where-Object, 51–54, 59, 73–75, 77, 80,

tanúsítvány, 83–85, 154, 158, 162, 166 81, 93, 119, 120, 122, 129–131, 143, 151,
tanúsítványtár, 84, 144, 145, 159, 166 154, 157, 159, 163, 166, 168
tartomány, 42, 110, 114, 166 while ciklus, 50, 168
taskkill, 29 while, 49, 50, 116, 168
telepítés, 28, 83, 107 Win32_Desktop, 107
telepített program, 108 Win32_DesktopMonitor, 107
teljes hozzáférés, 95, 103 Win32_DiskDrive, 107
területi beállítás, 24, 65, 66, 92, 94, 118, Win32_LoggedOnUser, 107
147, 162, 165 Win32_NetworkAdapterConfiguration,
tick, 77 107
TimeGenerated, 80, 81, 122 Win32_NTDomain, 107
TimeSpan, 73, 78 Win32_OperatingSystem, 107
típus, 19 Win32_PhysicalMemory, 106, 108
ToString, 24, 37, 93, 107, 116, 117, 131, 138 Win32_Process, 107
TotalProcessorTime, 73 Win32_Processor, 107
többalakúság, 17, 19 Win32_Product, 108
többszálú, 22 Win32_Service, 108
törlés, 166 Win32_Volume, 106, 108
Traverse, 96 Windows Management Instrumenta-
tulajdonság, 16, 25, 34, 55, 111, 129, 167 tion, 105
Unrestricted, 82 Windows Server 2003, 21, 27, 28, 114
UPDATE, 117 Windows Server 2008, 27, 29, 114
URL-cím, 91, 147, 149, 152, 166 Windows Update, 28
Users, 11, 33, 39, 55, 56, 61, 63, 64, 77, Windows Vista, 27
91, 109, 110, 112–114, 129 Windows XP, 27
változó, 24, 31, 35, 44, 48, 50, 51, 54, 69– Windows-alkalmazás, 22, 106
71, 76, 90, 95, 103, 110, 117, 120, 167 Windows-szolgáltatás, 28, 108
végponti továbbítókiszolgáló, 130 Windows-tartomány, 86
Visual Basic, 14, 15, 22, 48, 106, 137, 149, WMI, 105–108, 148, 150, 153, 158, 168
153, 167 WMI-objektum, 106, 148, 150, 153, 158,
Visual Basic.NET, 22, 137, 149, 153, 167 168
Visual Basic-szkript, 14 WMI-osztály, 106
Visual C#.NET, 139, 144, 149, 153, 167 WorkingSet, 73–75, 138
visszaadott érték, 70, 167 Write, 96, 134, 138
W32Time, 80 WriteAttributes, 96
W3C Extended, 123 WriteData, 96
Warning, 119 WriteEntry, 119
Web Site, 137 WriteExtendedAttributes, 96
web.config, 137 Write-Gzip, 134
webhely, 21, 137, 163, 167 WriteKey, 104
webkiszolgáló, 123, 124, 143, 152–156, Write-Zip, 134
159, 167 XML, 21, 62, 97, 137
wget, 49, 91, 168 -xor, 41
WhatIf, 31 ZIP algoritmus, 134
192

Szalay Márton - PowerShell Példatár

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Szalay Márton - PowerShell Példatár

Uploaded by

Copyright:

Available Formats

A Microsoft, Active Directory, PowerShell, Windows, .NET, Windows Server 2003,

© Szalay Márton, 2008.

Felelős szerkesztő: Kis Balázs

A könyv szövegének helyességét és az elválasztásokat a MorphoLo-

SZAK Kiadó Kft.  Az 1795-ben alapított Magyar Könyvkiadók

3. fejezet: A rendszerfelügyelet alapjai a PowerShellben ........................ 69

Elidegenedtünk a technikától. Nem tudjuk már, mi van az autó mo-

1 Kamarás István: Sárkányos mese igazából. Móra, Budapest, 1979.

Szalay Márton gyakorló rendszergazdaként olyan könyvet írt a

Budapest, 2008. augusztus 17.

1.1. Új parancssor: a PowerShell

Még egy parancssor?

„Na, még egy parancssor. Még valami, amivel a Microsoft megnehe-

A rendszerhéjak használata létfontosságú az operációs rendszerekkel

az alkalmazások elindítása. Mindenkinek, aki használt már számító-

1 power: erő, hatalom; az angol nyelvben előtagként szokás a nagy teljesít-

Olyan, mint régen

A PowerShellel való ismerkedésünket kezdjük rögtön úgy, hogy el-

Mode LastWriteTime Length Name

Mode LastWriteTime Length Name

Mode LastWriteTime Length Name

Nagy meglepetés nem ér minket, az történik, amit vártunk: először

Mivel tud többet a PowerShell más

Az eddigi példákból úgy tűnik, hogy a PowerShell ugyanúgy műkö-

alkalmazzák. Ha a bash parancshéjat használjuk, és begépeljük az ls

Ha ebből csak azokra a fájlokra vagyunk kíváncsiak, amelyek nevé-

[martonsz@extra ~/ps]$ ls | grep .txt

Viszont nem mindegy, hogy mi áll a kifejezés bal oldalán. Ha az ls

[martonsz@extra ~/ps]$ ls -l | grep .txt

A fenti példákban az történt, hogy az ls parancs megkérdezte az ope-

2 Mindezt persze megtehettük volna az ls *.txt paranccsal is: ezt a megol-

ramot kell írnunk, amely először kikeresi a karakterláncból, hogy

Írhatunk Visual Basic-szkriptet is, hogy elkérje a Windowstól a

On Error Resume Next

Set fso = CreateObject("Scripting.FileSystemObject")

Ennek az a hátránya, hogy alapos Visual Basic-ismereteket igényel,

gyűjti belőlük azokat a fájlokat, melyek két hétnél régebbiek, és áthe-

1.2. Bevezetés az objektumorientált

tok száma, úgy váltak a programozási nyelvek – és a programok – is

dául a C++-nak vagy a C#-nak, három szolgáltatásuk van, amely

Mint említettük, az emberi gondolkodásban nagyon fontos a külön-

Az autó osztályból tehát úgy lesz az autó példánya, hogy az osz-

A szoftverfejlesztés egyik legnagyobb problémája, hogy a fejlesztett

Az embereknek szokásuk, hogy az objektumokat hierarchiába ren-

vezhetjük, illetve a hierarchiában lejjebb található objektumok örö-

Az objektumorientált programozás harmadik jellemzője a többala-

Osztályok, objektumok és metódusok

Az objektumok az adott dolgot leíró adatokból ( t u l a j d o n s á -

sokból áll. Felfoghatjuk egyfajta sablonként, amelyet arra használha-

1.3. Ismerkedés a .NET

A .NET a Microsoft előre gyártott objektumorientált környezete – tu-

A .NET legfontosabb szolgáltatásai

Programfuttató környezet: A .NET keretrendszer programfuttató

segítségével könnyebben készíthetünk eseményvezérelt, dinamikus

Amikor egy .NET-alapú nyelven programot írunk, majd azt lefordít-

amilyen az automatikus memóriakezelés, benne a s z e m é t g y ű j -

1.1. ábra: A .NET-programok futtatásának sémája

Amikor elindítunk egy .NET-programot, a köztes nyelvre (CIL) le-

Most áttekintjük a .NET azon objektumait, adattípusait és a rájuk jel-

adhatunk, a változó deklarálásakor meghatározott típusától függ. Ez

Azt is megnézhetjük, hogy a ma változó Year, Month, Day stb. tulaj-

3 Az utóbbival jobban járunk, mert a dátumok esetén a ToString() eredmé-

típusú objektumot tartalmaz. Ha a gyűjtemény neve datumok, akkor