Si vous utilisez GNU bash, vous pouvez également utiliser des macros client afin d'accéder aux commandes de shell de CA AppLogic® directement à partir des commandes CLI de votre propre ordinateur Linux ou d'un serveur Linux de type VDS s'exécutant sur la grille.
Les macros client pour les clients GNU Bash et OpenSSH permettent d'accéder facilement à toutes les fonctionnalités de 3tshell, l'interface de ligne de commande de CA AppLogic®, directement à partir de votre invite de shell locale.
Fonctionnalités :
Pour utiliser ce fichier sur votre système :
Vous pouvez également effectuer ces étapes dans le fichier.bashrc de sorte à ce qu'il soit disponible pour chaque instance de shell interactive que vous démarrez.
Une fois le fichier rmacros.sh chargé, les commandes suivantes deviennent disponibles à partir de l'invite de shell. Vous pouvez également utiliser les mêmes commandes dans un script non interactif en incluant simplement le fichier rmacros.sh de votre script avec la commande "source" :
Définit le nom d'hôte du contrôleur vers lequel diriger les commandes ultérieures. Cela doit être fait avant d'utiliser l'une des autres commandes.
Déconnecte du contrôleur. La session ssh maître avec le contrôleur est fermée.
Même résultat que de saisir la commande à l'invite de shell de CA AppLogic®. Cette forme est utile pour les commandes simples et pour des opérations de lot sans surveillance. Utilisez 3t -t pour les commandes qui exigent une interaction de l'utilisateur (par exemple, vol manage).
Idem 3t commande 3tshell quelconque, mais active le mode interactif, en exécutant le shell CA AppLogic® avec le pseudo-terminal ssh activé.
Appelle le shell CA AppLogic® interactif.
Définit l'application actuelle. Cette commande fonctionne de la même façon que la commande "ca" dans le shell interactif. L'exécution de 3t ca myapp ne fonctionne pas car une nouvelle instance du shell CA AppLogic® est démarrée chaque fois que la commande 3t est appelée.
Imprime le nom de l'application actuelle (comme défini par ca)
Ouvre un shell interactif dans une instance d'appliance en cours d'exécution dans l'application actuelle, ou dans l'application spécifiée. component est le nom complet de l'instance dans la hiérarchie d'applications. Le nom de l'assemblage de niveau supérieur (main.) peut être ignoré, par exemple, les propositions suivantes sont équivalentes :
assh the-app:main.web.srv1 ca the-app ; assh web.srv1
Exécute une commande non interactive sur une instance d'appliance. REMARQUE : sur les versions plus anciennes (1.x) de CA AppLogic®, le nom de commande et les arguments ne peuvent pas contenir d'espaces, au risque de ne pas fonctionner comme prévu :
assh web.srv1 cat "the file with spaces in its name".
Si vous devez effectuer cette procédure sur une grille plus ancienne, créez un script court et copiez-le dans l'appliance en cours d'exécution avec la commande ascp ci-dessous, puis lancez ce script.
Copie un fichier vers une appliance en cours d'exécution ou à partir de cette appliance. L'un des paramètres src ou dest doit être le nom d'un répertoire ou fichier local. L'autre spécifie l'appliance distante et le nom de fichier sous une forme similaire à celle de la commande scp :
comp.name:filename
Le nom du composant est le chemin complet du composant dans l'assemblage d'application (comme pour assh, le préfixe main. peut être ignoré). Cette commande exige que l'application actuelle soit définie avec la commande ca.
Raccourci. Idem 3t app list.
Raccourci. Idem 3t app start `pwa`.
Raccourci. Idem 3t app stop `pwa`.
Non pris en charge par CA AppLogic® 2.3 et versions ultérieures. Utilisez plutôt l'opération new vol manage.
Non pris en charge par CA AppLogic® 2.3 et versions ultérieures.
Configuration des options SSH personnalisées
Outre la façon normale de définir des options SSH (les placer dans votre fichier ~/.ssh/config), les commandes fournies par rmacros.sh acceptent également un paramètre de variable d'environnement avec des options qui affectent uniquement les appels ssh générés par les macros, mais pas par les autres commandes ssh. Cette option est utile si vous avez besoin d'une configuration différente pour les grilles CA AppLogic® et pour d'autres sessions ssh, et que la méthode per-host prise en charge par le fichier .ssh/config n'est pas appropriée pour séparer les différentes options. C'est notamment le cas lorsque vous disposez également d'un accès "responsable de la maintenance" à la grille CA AppLogic® (par exemple, si vous avez installé cette grille) : vous avez une clé SSH qui fournit un accès racine au contrôleur - pas ce qui doit fonctionner comme "client" normal.
Pour fournir d'autres options aux macros d'accès distantes dans rmacros.sh, définissez la variable AL_SSH_OPT. Elle doit contenir des options sous une forme acceptée par ssh et tous ses programmes similaires (scp, sftp, etc.) : -o OptionName=option-value. N'utilisez d'options raccourcies comme -i, -t, etc. - elles fonctionnent avec ssh, mais pas avec scp.
Exemple : export AL_SSH_OPT='-o IdentityFile=/home/lk/t-key -o IdentitiesOnly=yes -o StrictHostKeyChecking=no'
Cela indique à SSH : Utilisez la clé /home/lk/t-key pour l'authentification par clé publique ; n'utilisez pas de clés fournies par ssh-agent ; désactivez la vérification d'identité d'hôte stricte (utilisez cette dernière option uniquement s'il vous arrive fréquemment de réinstaller des grilles complètement, ce qui entraîne une modification permanente de l'ID SSH du contrôleur).
Accès rapide et facile avec la session SSH maître
Les fonctions définies dans rmacros.sh utilisent la fonctionnalité de session maître du client OpenSSH. La première commande exécutée démarre un client ssh d'arrière-plan en mode maître, et toutes les commandes ultérieures utilisent la session gérée par le maître pour exécuter des sessions ssh supplémentaires sur le même canal sécurisé.
Cela offre deux avantages : premièrement, la saisie d'une phrase secrète pour accéder à la clé privée SSH n'est nécessaire qu'une seule fois - par la suite, la session reste ouverte et aucune connexion supplémentaire n'est réalisée.
Deuxièmement, les nouveaux appels de ssh sont aussi rapides, sinon plus, que la saisie de commandes dans une session SSH déjà ouverte, car la commande est envoyée une fois, lorsque vous appuyez sur Entrée, tandis qu'une session interactive utilise un écho caractère par caractère à mesure que vous tapez la commande.
En outre, exécuter les commandes localement à partir de votre shell et non à partir de la console 3tshell permet de tirer pleinement parti du shell, pour créer des commandes qui ne sont pas possibles avec une session 3tshell interactive, par exemple :
Obtenir une liste des applications en cours d'exécution :
3t app list | grep running
Enregistrer la liste des volumes dans un fichier :
3t vol list --all >file
Transférer une configuration d'une application à un autre :
3t app config app1 --batch | 3t app config app2 --stdin
Ce chapitre traite des sujets suivants :
Remarque : Le code fourni ici illustre une manière d'améliorer et de simplifier l'accès à l'interface de ligne de commande AppLogic via ssh. Il est fourni tel quel et ne fait pas partie du code pris en charge par AppLogic. Le support CA ne fournit pas d'aide, de mises à jour ou de correctifs pour ce code. Les erreurs et les omissions trouvées ici peuvent être signalées à CA et ce fichier sera corrigé si nécessaire, dans le cadre du cycle habituel de mise à jour de la documentation en ligne de CA.
#!/bin/bash
# Macros client pour l'accès au contrôleur de grille AppLogic
# (C) L.Kalev 2006 (lion//3tera.com)
# répertoire temporaire pour sockets de session maître
export CSPATH=/tmp/apl_lnkroot
# nom du contrôleur
export AL_CTL
export AL_CTLSOCKOPT
export PWA
ssh_cmd="ssh -l root $AL_SSH_OPT"
# !! _FS doit correspondre à la valeur définie dans "3trsh" pour fonctionner.
_FS='`'
function pack()
{
local i="$IFS"
IFS="$_FS"
ARGS="$*$_FS"
IFS="$i"
return 0
}
## décompresser
#OLD_IFS="$IFS"
#si [["$T" = *$_FS*]] ; alors IFS="$_FS" ; fi
#définir $T
#IFS="$OLD_IFS"
function controller ()
{
[[ -z "$1" ]] && { echo $AL_CTL ; return 0 ; }
local OPT_FC=
if [ "$1" = '-f' ] ; then OPT_FC=1 ; shift ; fi
[[ "$1" != "$AL_CTL" ]] && PWA=
# éteindre l'ancienne connexion, si nécessaire
if [[ -n "$AL_CTL" ]] && [[ -S $CSPATH/$AL_CTL ]] ; then
if [[ -z "$OPT_FC" ]] && [[ "$1" != "-" ]] ; then
AL_CTL=$1
AL_CTLSOCKOPT="-o ControlPath=$CSPATH/$AL_CTL"
return 0 # ne pas reconnecter si la connexion est ouverte
fi
echo "Closing old connection to $AL_CTL" >&2
kill $(<$CSPATH/$AL_CTL.pid)
fi
AL_CTL=$1
if [ "$AL_CTL" = '-' ] ; then AL_CTL= ; return 0 ; fi # disconnect only
# assurez-vous qu'il n'y ait pas d'espaces ni d'autres problèmes
set -- $AL_CTL
[[ "$1" != "$AL_CTL" ]] && { echo "invalid hostname" >&2 ; return 1 ; }
ping -c 1 -n -q "$AL_CTL" >/dev/null || echo "warning: ping $AL_CTL failed"
AL_CTLSOCKOPT="-o ControlPath=$CSPATH/$AL_CTL"
}
function sock-chk ()
{
[[ -z "$AL_CTL" ]] && { echo "controller name not set, use the 'controller' command to set it" >&2 ; return 1 ; }
if [[ -S $CSPATH/$AL_CTL ]] ; then return 0 ; fi
mkdir -p $CSPATH
# rediriger tous les descripteurs du processus ssh en arrière-plan, dans le cas où notre
# parent attend eof sur un descripteur std (il ne l'obtiendra pas si le descripteur
# est doub()lé dans le ssh répliqué)
$ssh_cmd -M -N -f $AL_CTLSOCKOPT $AL_CTL >/dev/null </dev/null 2>$CSPATH/$AL_CTL.2
local R=$?
if [[ $R != 0 ]] ; then
cat $CSPATH/$AL_CTL.2 >&2
return $R
fi
T=`ps -C ssh -o pid,args | grep -e "-M -N -f $AL_CTLSOCKOPT"`
set -- $T
echo $1 >$CSPATH/$AL_CTL.pid
return 0
}
function 3t ()
{
sock-chk || return 1
local T=
local A=
[[ $# == 0 ]] && T=-t
if [[ "$1" = '-t' ]] ; then T=-t ; shift ; fi
[[ -n "$PWA" ]] && A="=$PWA"
local TC1 TC2
TC1=`stat --format '%Y' $CSPATH/$AL_CTL.2`
ARGS="$A"
if [ $# != 0 ] ; then pack $A "$@" ; fi
$ssh_cmd $T -o LogLevel=ERROR $AL_CTLSOCKOPT $AL_CTL "$ARGS"
A=$?
TC2=`stat --format '%Y' $CSPATH/$AL_CTL.2`
if [[ "$TC1" != "$TC2" ]] && ! [[ -S $CSPATH/$AL_CTL ]] ; then
echo "Connection to controller lost, re-run the command to reconnect"
return 1
fi
return $A
}
function ca ()
{
[[ -n "$1" ]] || { PWA= ; return 0 ; }
# [[ -n "$1" ]] || { echo "use: ca app-name" >&2; return 1; }
3t app info "$1" >/dev/null || return $?
export PWA=$1
return 0
}
function pwa ()
{
echo $PWA
}
function assh ()
{
[[ -z "$1" ]] && { echo "use: assh [app:]comp" >&2 ; return 1 ; }
local APP
# cet élément peut être supprimé lorsque nous corrigeons l'actuel. prise en charge d'application en 3trsh
if [[ $1 == *:* ]] ; then
APP=$1
else
[[ -z "$PWA" ]] && { echo "current app not set, use full name" >&2; return 1; }
APP=$PWA:$1
fi
sock-chk || return 1;
shift
local T=
if [[ -z "$@" && -t 0 && -t 1 ]] ; then
# echo "using tty"
T=-t
fi
local TC1 TC2
TC1=`stat --format '%Y' $CSPATH/$AL_CTL.2`
ARGS="sh $APP"
if [ $# != 0 ] ; then pack sh $APP "$@" ; fi
$ssh_cmd $T $AL_CTLSOCKOPT $AL_CTL "$ARGS"
TC2=`stat --format '%Y' $CSPATH/$AL_CTL.2`
if [[ "$TC1" != "$TC2" ]] && ! [[ -S $CSPATH/$AL_CTL ]] ; then
echo "Connection to controller lost, re-run the command to reconnect"
return 1
fi
}
function ascp ()
{
# temporaire - l'opération sans l'application actuelle peut attendre
[[ -n "$PWA" ]] || { echo "current app. not set" >&2; return 1; }
sock-chk || return 1
# NB : "local" et la correspondance substr {#} sont spécifiques à "bash" et ne fonctionneront pas sur un shell Bourne std
local A1=$1
local P1=${1%%:*}
local P2=
local S1=
if [[ "$P1" != $1 ]] ; then # $1 is remote
S1=${1#*:}
[[ $S1 == /* ]] || S1=/root/$S1
[[ -n $P1 ]] || return 1;
A1="root@$AL_CTL:/app/$PWA/$P1$S1"
fi
local A2=$2
P1=${2%%:*}
if [[ "$P1" != $2 ]] ; then # $2 is remote
S1=${2#*:}
[[ $S1 == /* ]] || S1=/root/$S1
[[ -n $P1 ]] || return 1;
A2="root@$AL_CTL:/app/$PWA/$P1$S1"
fi
# devrait avoir les mêmes options que $ssh_cmd
scp $AL_SSH_OPT $AL_CTLSOCKOPT "$A1" "$A2"
}
# ---------- raccourcis divers
function als ()
{
3t app list
}
function astop ()
{
3t app stop "$@"
}
function astart ()
{
3t app start "$@"
}
# pas très utile pour le moment (nécessaire afin de monter sur NOTRE système)
function vmnt ()
{
3t vol mount "$@"
}
function vumnt ()
{
3t vol unmount "$@"
}
# ssh $T -S /tmp/opty3sk -i ~/t-key -o IdentitiesOnly=yes
# master start
# ssh -A -i ~/t-key -M -S /tmp/opty3sk -N -f -o IdentitiesOnly=yes $AL_CTL
|
Copyright © 2013 CA.
Tous droits réservés.
|
|