Vous souhaitez modifier les propriétés générale de la ressource cluster DHCP server en Powershell.
Récupérer dans 3 variables les Paths que vous voulez définir pour :
- Database path
- Audit file path
- Backup path
$DatabasePath="j:\dhcp\db"
$AuditFilePath="j:\dhcp\logs"
$BackupPath="j:\dhcp\backup"
Récupérer maintenant votre ressource de type DHCP Service
$RessDHCP=get-ClusterResource "DHCP Server"
Nous allons maintenant manipuler des instances basées sur Microsoft.FailoverClusters.PowerShell.ClusterParameter qui va nous permettre de manipuler nos propriétés.
Modification du Database Path
$param1 = New-Object Microsoft.FailoverClusters.PowerShell.ClusterParameter $RessDHCP,DatabasePath,$DatabasePath
$param1 | Set-ClusterParameter
Modification de l'Audit File Path
$param2 = New-Object Microsoft.FailoverClusters.PowerShell.ClusterParameter $RessDHCP,LogFilePath,$AuditFilePath
$param2 | Set-ClusterParameter
Modification du Backup path
$param3 = New-Object Microsoft.FailoverClusters.PowerShell.ClusterParameter $RessDHCP,BackupPath,$BackupPath
$param3 | Set-ClusterParameter
Les propriétés sont maintenant définis.
Vous souhaitez créer en ligne de commande un groupe de ressource Cluster.
Pour cela, il faut utiliser la ligne de commande suivante :
([wmiclass]"root\MSCluster:MSCluster_ResourceGroup").CreateGroup(“NomDuGroupe”, XXX)
Ou XXX représente l’identifiant du groupe de ressource que vous voulez créer.
Par exemple : pour créer un groupe de ressource Hyper-V réplica Broker, vous devez saisir l’ID 115 soit :
([wmiclass]"root\MSCluster:MSCluster_ResourceGroup").CreateGroup(“NomDuGroupe”, 115)
Maintenant, pour créer un groupe de ressource DHCP Cluster, l’identifiant correspondant est le 102 soit :
([wmiclass]"root\MSCluster:MSCluster_ResourceGroup").CreateGroup(“NomDuGroupe”, 102)
Ci-dessous, une capture d’écran qui vous donnera l’ID associé à un type de groupe de ressource Cluster.
Vous avez appliqué une image wim sur votre poste depuis WinPe et vous avez besoin de changer le nom de machine qui sera utilisé par la phase Specialize du Sysprep avant de rebooter la machine (pour sa prise en compte).
Charger le fichier xml situé dans le répertoire Windows\Panther dans une variable. (positionné ici après le travail de généralisation du Sysprep)
$xml="C:\Windows\Panther\unattend.xml"
[xml]$xml=get-content $xml
Ensuite via cette ligne de commande, saisissez le nom de votre Poste:
$xml.unattend.settings[1].component[1].computername="NomDuPoste"
(il se peut que dans votre fichier unattend, le noeud “computername” soit positionné ailleurs. Il vous faudra alors parcourir votre variable $xml et identifier ou se trouvera le nœud.)
Maintenant sauvegarder votre fichier XML avec la modification apportée.
$xml.save("C:\Windows\Panther\unattend.xml")
Maintenant lorsque vous redémarrerez votre poste, après la passe spécialize et oobe, le hostname du poste sera celui qui aura été renseigné dans la modification apporté dans le fichier xml.
Vous souhaitez contrôler l’accès à un fichier / répertoire en ligne de commande.
Pour cela, vous pouvez utiliser la classe Win32_Directory qui contient une méthode GetEffectivePermission. Celle ci permet de déterminer si le compte dispose des autorisations qui seront spécifiés dans notre commande.
Tout d’abord, récupérer le répertoire (pour l’exemple) que vous désirez contrôler.
En regardant maintenant les propriétés via la commande (gwmi Win32_directory -filter "name = 'c:\\temp'") |gm , on peut voir l’accès à la méthode GetEffectivePermission.
Nous voulons contrôler si l’utilisateur courant dispose des droits d’accès en écriture sur le répertoire c:\temp.
Pour cela, il faut saisir la valeur décimale 2 pour la méthode GetEffectivePermission.
Si l’utilisateur à les droits en écriture sur cette ressource, la commande nous renverra True. Dans le cas contraire, la commande nous renverra False.
Exemple :
(gwmi Win32_directory -filter "name = 'c:\\temp'").GetEffectivePermission(X)
X correspondant au droit contrôlé.
L’utilisateur peut donc accéder en écriture dans le répertoire.
Ci dessous un tableau contenant les valeurs à indiquer à la fonction GetEffectivePermission() pour le contrôle d’un droit spécifique
Dans certains contexte, nous avons besoin qu’un script Powershell ne soit exécuté que si la fenêtre Powershell n’a été lancée qu’en tant qu’administrateur.
Pour effectuer ce contrôle et lancer l’exécution du script :
$currentUser = New-Object Security.Principal.WindowsPrincipal $([Security.Principal.WindowsIdentity]::GetCurrent())
if (($currentUser.IsInRole([Security.Principal.WindowsBuiltinRole]::Administrator)) -eq $false)
{
write-host "Merci de relancer le script avec élévation de privilèges" -f red -b yellow
}
else
{
############################################### Saisissez votre code
###############################################
}
Maintenant si vous lancez votre script Powershell sans exécuter d’élévation, voici le résultat :
Imaginons maintenant que nous voulons exécuter un script uniquement si le compte utilisé dispose du droit domain admin :
Tout d’abord vous devez identifier le SID du groupe domain admin.
Une fois identifié voici un exemple d’intégration pour appliquer cette condition:
$currentUser = New-Object Security.Principal.WindowsPrincipal $([Security.Principal.WindowsIdentity]::GetCurrent())
$DroitDomainAdmin=0;$currentUser.Identities.groups | %{if($_.value -eq "S-1-5-21-XXXXXXXXXXXXXXXXXXXX"){$DroitDomainAdmin=1}}
### S-1-5-21-XXXXXXXXXXXXXXXXXXXX correspond à votre SID du groupe domain admin
if ($DroitDomainAdmin -eq "0")
{
write-host "Vous ne disposez pas du jeton Domain\Domain Admins" -f red -b yellow
write-host "Merci de vous l'attribuer et de relancer le script" -f red -b yellow
}
else
{
############################################### Saisissez votre code
###############################################
}
(Ce script est exécuté sous Powershell en version 3)
Vous disposez d’un plan de câblage identique pour plusieurs serveurs sur un même modèle. Chaque cartes réseaux sur les différents serveurs doivent être configurés de façon identique : même nom d’interfaces, mêmes protocoles, etc..
Afin d’identifier de manière automatiser les interfaces, vous pouvez vous baser sur le paramètre de localisation des interfaces (sur un même modèle de serveur).
Exemple :
Nous allons ici chercher à récupérer le nom de l’interface (pouvant varier d’une installation à l’autre en fonction de l’ordre de détection des interfaces réseaux)
Ici, nous allons identifier les différentes cartes réseaux et leurs emplacement :
Get-WMIObject Win32_PnPSignedDriver | ? {$_.deviceclass -match "NET"} |select description, location
Nous avons pu identifier la valeur correspondante à notre carte réseau.
Nous allons maintenant récupérer son nom d’interface présent dans le gestionnaire des connexions réseaux (ncpa.cpl)
$location=”PCI bus 3, device 0, function 0”
#### deviceclass retourne les résultats des périphériques PnP de type réseaux
Get-WMIObject Win32_PnPSignedDriver |? {$_.location -match $location -and $_.deviceclass -match "NET"} |%{$_.friendlyname} | %{Get-NetAdapter -InterfaceDescription $_} | %{$_.name}
Exemple pour l’inteface Wifi :
Dans un processus d’automatisation de la création du cluster ou Ajout d’un nœud dans le cluster, vous pourriez avoir besoin de récupérer le résultat de la validation dans un tableau afin de déterminer s’il est possible de lancer une création ou ajout dans le cluster.
Voici un exemple de script qui vs vous permettre de récupérer le résultat de la validation dans un tableau en powershell :
##### Validation Cluster
$logCluster="C:\Windows\Cluster\Reports"
$testCluster= Test-Cluster -Node $env:computername #-ErrorAction SilentlyContinue
sleep -s 5
$testCluster=$testCluster -replace(".mht",".xml")
[xml]$xml=get-content $testCluster
$ValidationTab=@()
$cpt=0
foreach ($x in $xml.report.Channel.channel)
{
$d=new-object psobject
$ChannelNames=$x.ChannelName."#cdata-section"
$values=$x.result.value."#cdata-section"
$d | Add-Member -Name ChannelNames -MemberType NoteProperty -Value "$ChannelNames"
$d | Add-Member -Name values -MemberType NoteProperty -Value "$values"
$ValidationTab+=$d
$cpt++
}
write-host "résultat de la validation du Cluster:" -f green
write-host ""
$ValidationTab
Exemple de Résultat :
Nous disposons d’une variable de type tableau avec comme informations des utilisateurs et leurs villes.
Nous allons ici créer dynamiquement une variable pour chaque site présent dans la variable $users et y affecter les utilisateurs.
Nous allons créer une variable de type tableau dans lesquels nous allons récupérer tous les sites disponibles dans notre variable $users.
$sites=@()
Nous alimentons maintenant la variable $sites.
foreach ($user in $users)
{
$sites+=$user.extensionAttribute8
}
$sites=$sites |sort | Get-Unique
Résultats :
Maintenant nous allons créer pour chacun des sites récupérés une variable avec pour nom la valeur récupéré dans la variable $sites
$sites | %{New-Variable -Name $_ -value @() -ErrorAction SilentlyContinue; if ($? -eq $true){write-host "variable créé : $_"}}
Résultats :
Maintenant nous allons alimenter dans les variables créés précédemment dynamiquement les utilisateurs présents dans les sites
foreach ($user in $users)
{
$VariableValue = $Null
$user.extensionAttribute8 |%{$VariableValue = @(((Get-Variable $_).Value)+$user);Set-Variable -name $_ -value $VariableValue}
}
Résultats :
Nous allons pour l’exemple créer un fichier n’ayant pas le droit administrateurs.
Les autres fichiers ont bien le droit administrateurs dans leurs ACL.
Maintenant à l’aide d’un script, nous allons détecter le/les fichiers n’ayant pas l’identité “administrateurs”
Positionnons nous dans le répertoire nous intéressant et récupérons les différents éléments
cd "C:\Users\ato\Dropbox\Divers"
dirs=get-item *
maintenant on créer un tableau ou seront ajoutés les différents éléments n’ayant pas le droits administrateurs
Ensuite à l’aide du code ci dessous, nous allons être capable de récupérer dans le tableau $acl les éléments de notre recherche:
foreach ($d in $dirs)
{
$ID=(get-acl $d).access | %{$_.identityreference}
if ($ID -match "administrateurs"){} #c’est ici que l’on définit l’acl manquant que l’on recherche
else
{
$d.fullname
$acl=$d.fullname
}
}
Apres exécution du script, on peut voir que la variable $acl a bien été définis avec le fichier n’ayant pas le droit administrateur
Imaginons que vous devez supprimer à un emplacement donné des répertoires et/ou fichiers n’ayant pas été modifiés depuis 30 jours.
Ce petit script va permettre d’identifier les éléments correspondant à notre critère de recherche.
Positionnons nous dans le répertoire nous intéressant
cd "C:\Users\ato\Google Drive"
On obtient tous les items à notre emplacement
$items= get-item *
Un petit compteur pour identifier le nbre d’éléments qui nous sera retourné
$i=0
Nous allons maintenant récupérer le chemin absolu des items n’ayant pas été modifié depuis au moins 30 jours.
foreach ($item in $items)
{
$days=($item |New-TimeSpan).days
if ($days -ge 30) # c’est ici que nous définissons le nbre de jours
{
$i++
$item.fullname
}
}
echo "Nbres item $i"
Il y a donc 83 items n’ayant pas été modifié depuis au moins 30 jours.
Sur un total de 114 items
Il ne vous reste plus qu’à ajouter un remove-item dans la boucle de traitement si vous souhaitez supprimer les items renvoyés.