Lister les sauvegardes Netbackup en cours

Si le champ de la colonne n°3 de la commande netbackup bpdbjobs -report -most_columns est inférieur à 3, c’est qu’il y a des sauvegardes en cours, ou en préparation.

	bpdbjobs -report -most_columns | awk -F"," '{ if( $3 < 3 ){ print } }' 

Rien à voir avec les sauvegardes en cours, mais voici une autre commande netbackup que j’utilise beaucoup pour lister les policies (stratégies de sauvegarde) et les clients :

bppllist 

# Détails d'une policie
bppllist MAPOLICIE -U 

# Lister des policies en filtrant avec un client
bppllist -byclient MONCLIENT

# Lister les clients 
bpplclients

(voir plus) Lister les sauvegardes Netbackup en cours

01-07-2015

IHM VTOM via un tunnel ssh

Enfin un truc fun ! (merci Stéphane pour l’astuce du tunnel)

Je suis sûr que ça vous est déjà arrivé d’avoir un serveur VTOM dans une DMZ (une zone démilitarisée sécurisée) et, de n’avoir que le port ssh d’ouvert pour vous connecter en putty au serveur.

Du coup, pas d’IHM VTOM sur votre poste de travail (IHM = Interface Homme Machine = console graphique d’admin et pilotage VTOM).

Qu’à cela ne tienne ! avec cette astuce, on peut créer un tunnel ssh de votre poste de travail vers votre serveur VTOM. On redirige alors tous les flux nécessaires (vtnotifier 30008 et vtserver 30007, ou les votres perso) de votre poste vers le serveur VTOM.
- Configurer le tunnel ssh avec les flux VTOM dans PuTTY
```
PuTTY Configuration > Connection > SSH > Tunnels :
Source Port = 30007
Destination = <@IP ou nom DNS du serveur VTOM>:30007 
==> Add
```
```
Source Port = 30008
Destination = <@IP ou nom DNS du serveur VTOM>:30008
==> Add
```
A vérifier, mais il faut peut-être rajouter les services dans %systemroot%\system32\drivers\etc\services
```
vtserver 30007
vtnotifier 30008
```
(ou vos ports spécifiques)
- Se connecter au serveur VTOM avec PuTTY pour créer le tunnel ssh
Connexion classique. PuTTY Configuration > Session > Host Name (or IP) = @IP du serveur VTOM

Et “Open”
- Se connecter à VTOM via l’IHM depuis votre poste de travail
Ouvrir l’IHM VTOM, et mettre localhost au lieu du serveur VTOM. Et, voilà !

Rapport snapshots VMWare Powershell

    Export-Console "C:\Program Files (x86)\VMware\Infrastructure\vSphere PowerCLI\vim.psc1"
		import-module "C:\Program Files (x86)\VMware\Infrastructure\vSphere PowerCLI\Scripts\Initialize-PowerCLIEnvironment.ps1"
		Connect-VIServer -Server $script:VCENTER_SERVER -Protocol https -User $script:VCENTER_USER -Password $script:VCENTER_PASSWORD
		if($? -ne $True){
			fn_WriteLog "ERROR -- Impossible de se connecter au vCenter ${VCENTER_SERVER}"
			$script:vRC_CODE=20
			break
		}
		
		# Récupération des snaphots
		$script:SNAPSHOTS = get-vm |  foreach { $VM = $_ ; $_ } | get-snapshot | select VM,@{Label="VM Powerstate";Expression={$VM.PowerState}},Name,Description,@{Label="Size";Expression={"{0:N2}" -f ($_.SizeGB)}},Created
		# On tri selon les critères en paramètre 
		# et on filtre sur le ou les pattern
		$PATTERN = @()
		$script:SNAPSHOT_PATTERN | foreach { $_.getEnumerator() } | foreach { $PATTERN += "`$_." + $_.key + " -match `"" + $_.value + "`"" }
		$PATTERN = $PATTERN -join " -or "
		if($script:SNAPSHOT_SORT_DESCENDING){
			$script:SNAPSHOTS = $script:SNAPSHOTS | sort-object $script:SNAPSHOT_SORT_BY -descending | where-object { invoke-expression $PATTERN }
		}else{
			$script:SNAPSHOTS = $script:SNAPSHOTS | sort-object $script:SNAPSHOT_SORT_BY | where-object { invoke-expression $PATTERN }
		}
		
		if($? -ne $True){
			fn_WriteLog "ERROR -- Impossible de récupérer la liste des snapshots"
			$script:vRC_CODE=21
			break
		}
		
		# On se déconnecte
		Disconnect-VIServer -Server $script:VCENTER_SERVER -Force:$true -Confirm:$false
		

Pas de retour tsend client vtom unix

Il peut arriver qu’un traitement s’exécute bien (code retour 0 terminé OK) mais qu’on n’ait pas de retour tsend sur VTOM (terminé en erreur)

Si le retour s’effectue bien avec l’utilisateur de soumission “vtom” ou “root” mais pas pour les autres utilisateurs, il y a de grandes chances que les droits du répertoire spool ne soient pas en 777 comme ils devraient l’être.

sendmail pour vtom

#!/bin/ksh
#On prend les 3 premiers arguments pour sujet, sender, dest
SUJET="$1"
shift
SENDER="$1"
shift
DEST="$1"
shift

# $@ ==> tous les autres arguments constitueront le body du message mail
(
cat << EOF
From: $SENDER 
To: $DEST
Subject: $SUJET
Content-Type: text/html
EOF
echo "<html><h1>$SUJET</h1><body>" 
while test $# -gt 0
do
  echo $1"<br>" 
  shift
done
echo "</body></html>"
) | sendmail -oi -t

Extraction des crontabs de tous les utilisateurs en local ou à distance

Le principe est d’exécuter crontab -l -u user (linux) ou crontab -l user (solaris) pour tous les utilisateurs et pour tous les serveurs distants passés en paramètre dans un fichier.

Voici comment récupérer facilement la liste de vos clients :

vtmachine | awk  -F"|" '$7 ~ /Win/ {print $3}' | sed 's/^[ \t]*\|[ \t]*$//g' > /var/tmp/liste_client_windows.txt
vtmachine | awk  -F"|" '$7 ~ /Sol|Lin/ {print $3}' | sed 's/^[ \t]*\|[ \t]*$//g' > /var/tmp/liste_client_unix.txt

Script shell à télécharger : Extract_Crontab.sh

# Script qui pousse un sous-script permettant d'afficher la crontab de tous les utilisateurs
# et l'exécute sur des serveurs distants 
# ou en local si aucun paramètre
# A lancer en root

# Le premier paramètre doit être le chemin complet d'un fichier listant des serveurs linux ou Solaris
# Le serveur sur lequel est exécuté le script doit pouvoir communiquer en ssh avec les serveurs distants
FIC_LISTE_SERVEURS=$1

# On set le code retour à 0
CR=0

# Sous-script à exécuter sur les serveurs distants
FIC_SUBSCRIPT=/var/tmp/`basename $0`_${RANDOM}_`date +"%d%m%Y"`.sh

# fichier de sortie des crontabs -l des utilisateurs 
# format hostname;user;ligne crontab (commentaires et lignes vides non prises en compte)
FIC_SORTIE_EXT_CRONTAB=/var/tmp/`basename $0`_${RANDOM}_`date +"%d%m%Y"`.csv
> ${FIC_SORTIE_EXT_CRONTAB}

# Ecriture du sous-script
# si le crontab -l -u user ne fonctionne pas sur votre machine distante, on peut imaginer créer
# une couche d'abstraction pour la commande crontab selon l'OS
echo "awk -F\":\" '\$NF !~ /(nologin|sync|shutdown|halt|false)/ {print \$1}' /etc/passwd | while read user ;do \
export user; \
FIC_TEMP=/var/tmp/\${RANDOM}_crontab-l; \
crontab -l -u \${user} > \$FIC_TEMP 2> /dev/null ; \
if test \$? -ne 0 ; then \
 crontab -l \${user} > \$FIC_TEMP 2> /dev/null ; \
 if test \$? -ne 0 ; then \
  rm -f \$FIC_TEMP; \
  continue ; \
 fi ; \
fi ; \
while read line ; do \
 if test -z \"\$line\" ; then \
  continue ; \
 fi ; \
 echo \"\$line\" | grep \"^#\" > /dev/null 2>&1 ;\
 if test \$? -eq 0 ; then \
  continue ; \
 fi ; \
 printf \"%s;%s;%s;\\\n\" \"\`uname -n\`\" \"\${user}\" \"\${line}\" ; \
done < \${FIC_TEMP}; \
rm -f \$FIC_TEMP; 
done" > ${FIC_SUBSCRIPT}


# Si la liste des serveurs distants est vide, on exécute le sous-script en local
if test -z "${FIC_LISTE_SERVEURS}";then
  chmod +x ${FIC_SUBSCRIPT}
  ${FIC_SUBSCRIPT} >>  ${FIC_SORTIE_EXT_CRONTAB}
else
  NB_SERVEURS=`cat ${FIC_LISTE_SERVEURS} | wc -l`
  BOUCLE_COURRANTE=0

  
  while read SERVEUR_DISTANT
  do 
    BOUCLE_COURRANTE=`expr ${BOUCLE_COURRANTE} + 1`
    echo "INFO -- ${SERVEUR_DISTANT} : ${BOUCLE_COURRANTE}/${NB_SERVEURS}"
    
    # on continue dans la boucle si le ping ne fonctionne pas
    ping -c 1 ${SERVEUR_DISTANT} > /dev/null  2>&1
    if [ $? -ne 0 ];then
      echo "ERROR -- PING serveur ${SERVEUR_DISTANT}"
      CR=10
      continue
    fi
    
    # ssh -n dans une boucle while sinon on sort de la boucle à la première occurence
    # on continue si le ssh/scp ne fonctionne pas
    scp ${FIC_SUBSCRIPT}  ${SERVEUR_DISTANT}:/var/tmp/ > /dev/null
    ssh -n ${SERVEUR_DISTANT} "chmod 777 /var/tmp/`basename ${FIC_SUBSCRIPT}`"
    if [ $? -ne 0 ];then
      echo "ERROR -- SSH serveur ${SERVEUR_DISTANT}"
      CR=11
      continue
    fi

    ssh -n ${SERVEUR_DISTANT} "/var/tmp/`basename ${FIC_SUBSCRIPT}`" >> ${FIC_SORTIE_EXT_CRONTAB}

  done < ${FIC_LISTE_SERVEURS}
fi

exit $CR

Pour déployer facilement un script depuis le serveur VTOM vers tous les clients, on peut aussi utiliser le vtcopy

vtmachine | grep -i running | awk -F"|" 'BEGIN{printf "tremote /machine="}{gsub(/[ 	]/, "", $2); printf "%s,",$2;}END{printf " vtcopy -i monfic_source -o mon_rep_dest\n"}'

Version tâches planifiées Windows (filtre des tâches microsoft) schtasks /query :

@echo off
set USER=administrateur
set PASSWD=motdepasse
for /F %i in (c:\temp\liste_client_windows.txt) do (
schtasks /Query /FO CSV /V /S %i /U %USER% /P %PASSWD% | findstr /V "\Microsoft" | findstr /V '"HostName","TaskName","Next Run Time","Status","Logon Mode","Last Run Time","Last Result","Author","Task To Run","Start In","Comment"' 
) >> c:\temp\taches_planifiees_windows.csv
@echo on

Compter le nombre de traitements VTOM par client

Comment compter le nombre de traitements par client VTOM ?

Rien de bien sorcier :

#on liste tous les jobs et on redirige dans un fichier temporaire
tlist jobs > /var/tmp/tlistjobs

#on compte le nombre de lignes trouvées dans le fichier tlistjobs pour chaque client
tlist machine | while read machine
do
echo -e "$machine;"
nbJobs=`grep $machine /var/tmp/tlistjobs | wc -l`
echo -en "$nbJobs\n"
done

Lister le contenu d'un répertoire Github en ajax

But du jeu

Héberger un site de photographies sur les pages Github
Le site doit pouvoir récupérer dynamiquement les images push sur Github

Démo

Laure Photographies

Structure du site

img
- <prefix><nom d’un répertoire menu images>
- img_dyptique (dyptique sera un menu)
  - image1.jpg
  - image2.jpg

Méthode : ajax et API Github

Le principe est simple : il faut récupérer les informations du repository via l’API Github en ajax. Pas d’authentification, c’est juste du GET.

Les API Github :

repos
trees
Récupérer le dernier commit du repository (son sha)

$.ajax({
 url: "https://api.github.com/repos/laure-photographies/laure-photographies.github.io/branches",
 success: function(data){
  // récupération du dernier sha last commit du repos
  console.log(data[0].commit.sha) ;
 }
});

Lister le contenu du répertoire img/ où se trouve les répertoires préfixés qui constitueront les menus

$.ajax({
 // github_repo_sha qu'on a récupéré dans l'appel ajax précédant
 url: "https://api.github.com/repos/laure-photographies/laure-photographies.github.io/git/trees/"+github_repo_sha,
 success: function(data){
  
  // Récupération du sha du dossier img
  $.each(data.tree,function(){
   if( this.path == "img"){
    console.log(this.sha);
   }
  });
 }
});

Lister les images du menu

$.ajax({
 url: "https://api.github.com/repos/laure-photographies/laure-photographies.github.io/git/trees/"+img_sha,
 success: function(data){
  // data.tree array des items d'un menu
  $.each(data.tree,function(){
   // liste des noms des fichiers images
   console.log(this.path) ;
  });
 }
});

Héberger une page web depuis vthttpd web access VTOM

Comment héberger une page ou un site web depuis votre service vthttpd web access VTOM ? en utilisant les alias :

Pré-requis

service WebAccess VTOM installé (vhttpd)

Configuration du webacces VTOM

Modifier le vthttpd.ini
```
httpAliases="/monsiteweb/=C:\VTOM5\WWW\monsiteweb\"
httpAllowedURI=/monsiteweb/*
```
Se rendre sur la page de votre webacces VTOM suivi de l’alias ex. localhost:30080/monsiteweb/
Clients VTOM zones Solaris

Sur les superclusters Solaris, il ne faut pas faire un simple ps -eaf | grep bdaemon sous peine de voir tous les clients VTOM de toutes les zones (sortes de guest) du supercluster.

Le plus drôle arrive si on commence à kill les bdaemon des zones depuis le supercluster en croyant que c’était des bdaemons zombies, ça kill vraiment le client VTOM sur la zone.

C’est pourquoi il vaut mieux effectuer la commande ps -flz global | grep bdaemon pour afficher les process du supercluster et, ps -flZ | grep bdaemon pour voir tous les clients et les zones associées.

Autres commandes pratiques pour voir les zones : zoneadm list

Si global ==> supercluster, si plusieurs lignes avec des hostnames, ce sont les zones du supercluster.

Si une seule ligne avec le hostname ==> zone

Lister les sauvegardes Netbackup en cours

But du jeu

Démo

Structure du site

Méthode : ajax et API Github

Pré-requis

Configuration du webacces VTOM