VTY


Comandos VTY remoto

Ejecución de uno o más comandos de la CLI interactiva es una tarea común en la gestión de la red . Tener un script para automatizar esta tarea se convierte en una herramienta fundamental.
Este script automatiza sesiones telnet o SSH interactivas. Cualquier comando que se puede emitir en la CLI se puede emitir a través de la secuencia de comandos comando de marcha VTY de forma automatizada. A continuación se muestran algunos usos de ejemplo:
  • Ejecutar un conjunto de comandos en cientos de dispositivos
  • Los cambios de configuración
  • Archivo de configuraciones y software
  • Auditorías, inventario y descubrimiento
  • Automatizado de solución de problemas

Requerimientos

Este guión está escrito en esperar. Se requiere una versión actual de esperar. Esperar y requisitos de instalación de esperar se puede encontrar en Espera Homepage
Probado en RHEL 5 corriendo esperar 5.43.0-5.1 y Mac OS X 10.6 correr esperar 5.44.1.11.
La escritura es una plataforma independiente y debería funcionar en cualquier plataforma que pueda ejecutar esperar.

VTY Ejecutar Comandos

El script soporta opciones de línea de comandos para la configuración. A continuación se muestra una lista de las opciones de línea de comandos disponibles:
NotaNota :Ejecute la secuencia de comandos con vty_runcmd.exp <opciones>

Opciones Necesarias

OpciónValor de la opciónDescripción
-HNombre de host o dirección IPIntroduzca el nombre o la dirección IP del dispositivo para ejecutar el comando remoto en
-UNombre de usuarioIntroduzca el nombre de usuario de inicio de sesión o usuario del sistema, normalmente se requiere para Unix o conexiones AAA. Utilice ninguno si requiere login / nombre de usuario
-PcontraseñaIntroduzca la contraseña para el usuario / nombre de usuario del sistema abetos. Esta es la primera contraseña, el modo no de habilitación

Opciones opcionales

OpciónValor de la opciónDescripción
-EcontraseñaIntroduzca la contraseña de activación o secreta. Esto es para entrar en el modo de activación.
-TsegundoIntroduzca el tiempo de espera para esperar que espera en segundos
-Mssh o telnetIntroduzca ssh o telnet para el método de conexión. TELNET es el valor predeterminado. Para SSH, la secuencia de comandos entrará automáticamente en sí para entradas de host autorizado.
-Fnombre de archivoIntroduzca el nombre del archivo que se utiliza como archivo de comandos. Por defecto se usa STDIN

La automatización de secuencia de comandos para ejecutar en varios hosts

Consulte Comandos VTY remoto automatizado para obtener más detalles sobre la manera de ejecutar el script desde cron y cómo ejecutarla de forma circular para múltiples hosts.

Pasos para instalar la secuencia de comandos

  1. Corte y pegue el siguiente script en un archivo de texto llamado vty_runcmd.exp
  2. Editar la primera línea de la secuencia de comandos y actualice el " # / usr / bin / esperar - "comando para que señale al instaladaesperar binario
  3. (Unix, Linux, Mac OS únicamente) cambia el modo para que el script se ejecutará utilizando " chmod 755 vty_runcmd.exp "
  4. Ejecute la secuencia de comandos con " . / vty_runcmd.exp <opciones> "

Fuente de scripts

! # / Usr / bin / esperar -
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Vty_runcmd.exp
# 
# Este es un script de esperar que se conectará a un dispositivo mediante ssh o
# Telnet, a continuación, ejecute el comando especificado. La salida será ya sea
# Escrito a un archivo de salida o impresos en stdout.
#
# Creado por Tim Evens (tim@evensweb.com), 5/2009
# Rectificado por Sergio Zavala (sergio.zavala en sidetec.com.mx), 12/2010
#
# Copyright Tim Evens, 2009
#
# HISTORIA:
# Tim Evens 21/05/09 programa inicial creado
# Sergio Zavala 12/26/10 código de retorno Conexión corregida 
# Tim Evens 1/05/10 conexión validado
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

# + + + + + + + + + + + + + + + + + + + + + + + + + +
Vars # globales
# + + + + + + + + + + + + + + + + + + + + + + + + + +
establecer el tiempo de 30
# A continuación partidos instrucciones tales como "Router #", "Router>", "enrutador $"
conjunto de avisos "\> \ * $ | # \ * $ | \ \ $ \ * $"


# -----------------------------------------------
# Connect (método, sistema, serie, usuario, contraseña)
# Esta función se conecta a un host mediante telnet o ssh.
# 
# DEVOLUCIONES:
# Cero en caso de éxito
# 1 = método de host o tiempo de espera o no válido
# 2 = login válido
# 3 = tiempo de espera de espera de inicio de sesión
# 4 = Error de conexión al host durante esperar esperar
# 9 = error desconocido
# -----------------------------------------------
proc Connect {método anfitrión usr pw} {
   establecer rval 0
   establecer usr_chk 0
   establecer pw_chk 0
   establecer max_checks 4
   spawn_id mundial
   timeout mundial
   sistema mundial
  
   puts "Conexión mediante $ method a $ host como usuario $ usr"
   
   # Ver si estamos usando ssh
   si {[string comparar $ method "ssh"] == 0} {
      configurar host "$ usr @ $ host"
   }
   
   # Ejecutar comandos y conectarse
   ID SET [spawn $ method $ host]
   si {$ id <= 0} {
      pone "ERROR: No se pudo conectar al servidor \ n"
      establecer rval 1
      
   } Else {
      pone "Uso de Id. de proceso: $ id"
   }
   
   # Inicie el proceso esperado / enviado para iniciar sesión
   esperar {
   
      # A continuación se encarga de indicar al usuario
      -Nocase re-"Nombre: | ^ login:" {
         enviar "$ usr \ r"
         incr usr_chk;
         
         # Continuar con esperar bucle en tanto que no hemos tocado esto muchas veces         
         si {$ usr_chk <$ max_checks} {
            exp_continue
         } Else {
            establecer rval 2
            pone "ERROR:. Login reintento fallado nombre de usuario de inicio de sesión no válido"
         }   

       # A continuación se encarga de la solicitud de contraseña
       } Nocase-re "palabra:" {
         enviar "$ pw \ r"
         incr pw_chk;
         
         # Continuar con esperar bucle en tanto que no hemos tocado esto muchas veces
         si {$ pw_chk <$ max_checks} {
            exp_continue        
         } Else {
            establecer rval 2
            pone "ERROR:. Login reintento fallado contraseña de inicio de sesión no válido"
         }   
         
      # A continuación se encarga de la sin preguntar si / cuando SSH primero se conecta a un host   
      } Nocase-re "\ (sí / no \)" {
         enviar "sí \ r"
         exp_continue
      
      # A continuación se encarga de la pronta normales para detectar cuando se conectó
      } Nocase-re "$ mensaje" {
         pone "\ nSUCCESS: Conectado y listo para enviar comandos \ n"

      # A continuación es para esperar tiempo de espera de la espera de un                                 
      } Timeout {
         pone "ERROR: tiempo de espera de conexión de espera de inicio de sesión del sistema"
         establecer rval 3
      
      # A continuación se para cuando la conexión se cierra antes de terminar   
      Eof} {
         pone "ERROR: Conexión al anfitrión ha fallado: $ expect_out (buffer)"
         establecer rval 4
      }
   }
     
   # Devuelve el código de error
   return $ rval
} 
# Fin de Connect ()

# -----------------------------------------------
# Uso ()
# Esta función se imprimirá el uso
# -----------------------------------------------
Uso de proc {} {

   pone "Uso: vty_runcmd.exp <opciones>"
   pone "\ n"
   pone "opciones necesarias:"
   pone "-h <hostname|ip> = nombre de host o IP"
   pone "-u <nombre = nombre de usuario para iniciar sesión en"
   pone "-p <contraseña> = contraseña para inicio de sesión"
   pone "\ n"
   pone "Otras opciones"
   pone "-e <Enable contraseña> = Habilitar contraseña"
   pone "t-<segundos> = tiempo de espera en segundos"
   pone "-m = <ssh|telnet> uso sea ssh o telnet, telnet por defecto"
   pone "-f <nombre = archivo de comandos, por defecto es STDIN"
   pone "\ n"
}
# Fin de Check_ARGS ()

# -----------------------------------------------
# Main () 
# 
# DEVOLUCIONES:
# 0 en caso de éxito
# 1 si se aprueba inválida arg
# 2 no hay suficientes argumentos (args requeridas no se cumplen)
# -----------------------------------------------
   establecer rval 0
   configurar el nombre de host ""
   configurar nombre de usuario ""
   establecer la contraseña ""
   establecer enable_pw ""
   establecer cmdfile ""
   establecer método "telnet"

   # Loop a través de los argumentos de línea de comandos   
   de {set n 0} {$ n <$ argc} {n} {incr
   
      set arg [lindex $ argv $ n]
      
      # Compruebe los argumentos
      si {[string comparar $ arg "-u"] == 0} {
         si {$ n <$ n +1} {
            incr n
            configurar nombre de usuario [lindex $ argv $ n]
         } Else {
            establecer rval 1
            pone "ERROR: Falta ARG por $ arg \ n"
         }
    
      Elseif} {[string comparar $ arg "-p"] == 0} {
         si {$ n <$ n +1} {
            incr n
            establecer una contraseña [lindex $ argv $ n]
         } Else {
            establecer rval 1
            pone "ERROR: Falta ARG por $ arg \ n"
         }
         
      Elseif} {[string comparar $ arg "-h"] == 0} {
         si {$ n <$ n +1} {
            incr n
            configurar el nombre de host [lindex $ argv $ n]
         } Else {
            establecer rval 1
            pone "ERROR: Falta ARG por $ arg \ n"
         }

      Elseif} {[string comparar $ arg "-m"] == 0} {
         si {$ n <$ n +1} {
            incr n
            establecer el método [lindex $ argv $ n]

         } Else {
            establecer rval 1
            pone "ERROR: Falta ARG por $ arg \ n"
         }
         
      Elseif} {[string comparar $ arg "-t"] == 0} {
         si {$ n <$ n +1} {
            incr n
            establecer el tiempo [lindex $ argv $ n]
         } Else {
            establecer rval 1
            pone "ERROR: Falta ARG por $ arg \ n"
         }
 
      Elseif} {[string comparar $ arg "-f"] == 0} {
         si {$ n <$ n +1} {
            incr n
            establecer cmdfile [lindex $ argv $ n]
         } Else {
            establecer rval 1
            pone "ERROR: Falta ARG por $ arg \ n"
         }
         
      Elseif} {[string comparar $ arg "-e"] == 0} {
         si {$ n <$ n +1} {
            incr n
            set enable_pw [lindex $ argv $ n]
         } Else {
            establecer rval 1
            pone "ERROR: Falta ARG por $ arg \ n"
         }
      }
   }
   # Fin del check arg
        
   # Asegurarnos de que encontramos la cantidad de argumentos esperados   
   si {[llargo $ hostname]> 0 && [$ método llargo]> 0 && 
          [Llargo $ nombre de usuario]> 0 && [llargo $ password]> 0} {
      # Imprime los argumentos encontrados
      pone "nombre de host = $ host, usuario = $ usuario, $ password = pw, method = $ method"
      
   } Else {
      establecer rval 2
      pone "ERROR: Falta argumentos requeridos, debe tener-h,-u,-p \ n"
      Uso
   }
   
   # ------------------
   # Ahora que tenemos las ARGS correctos y sabemos qué hacer, vamos a proceder a
   # Conectarse, ejecutar los comandos, a continuación, salir.
   # ------------------
   
   # Asegurarnos de que no hemos encontrado ningún error
   si {$ rval <= 0} {
   
      si {[llargo $ cmdfile] <= 0} {
         pone "Introduzca el texto de envío (tipo" fin "en la última línea hasta el final):"
         expect_user-nocase-re "(. *) \ nend \ n"
         establecer send_text $ expect_out (1, cadena)
         
      } Else {
         puts "Uso de $ cmdfile para texto enviar"
         # Set cmdfile_fd [abierto $ cmdfile r]
         si {[catch {set cmdfile_fd [abierto cmdfile $ r]} err_msg]} {
            pone stderr "No se pudo abrir $ cmdfile para leer \ n $ err_msg"
            salida 1
         }
         
         # Leído en la información de archivo - Advertencia hay un límite en el tamaño
         establecer send_text [leer $ cmdfile_fd 10000]
         
         # Estrecha archivo abierto
         cerrar $ cmdfile_fd      
      }

      # Conectar y comprobar el estado de retorno antes de proceder
      si {[Conectar "$ method" "$ hostname" "$ usuario" "$ password"]> 0} {
         # Parar aquí, sin necesidad de imprimir un error ya Connect función hace que
         salida 1
      }

      
      # Si hay una contraseña de activación, permite tratar de enviarlo
      si {[llargo $ enable_pw]> 0} {
         pone "modo enable *** Utilizando"
         enviar "enable \ r"
         esperar {
            -Timeout 3
            # A continuación se encarga de la solicitud de contraseña
            -Nocase-re "palabra:" {
               enviar "$ enable_pw \ r"
               exp_continue
      
            # A continuación se encarga de la pronta normales para detectar cuando se conectó
            }-Re "# \ * $" {
               pone "- El éxito en el modo enable -"

            # A continuación es para esperar tiempo de espera de la espera de un                                 
            } Timeout {
               pone "ERROR: Habilitar tiempo de espera de contraseña"
               establecer rval 3
      
            # A continuación se para cuando la conexión se cierra antes de terminar   
            Eof} {
               pone "ERROR: Conexión al anfitrión ha fallado: $ expect_out (buffer)"
               establecer rval 4
            }         
         }
      }
      
      # Loop a través de la send_text y enviar una línea a la vez         
      foreach line [SPLIT $ send_text \ n] {
         # Asegúrese de excluir líneas vacías
         si {[llargo $ line]> 0} {           
            enviar "$ line \ r"
            
            # Inicie el proceso esperado / enviado para iniciar sesión
            esperar {            
               # A continuación maneja el sí / no mensajes  
               -Nocase-re "\ (sí / no \)" {
                  enviar "sí \ r"
                  exp_continue
               
               # A continuación se encarga de la s / n solicita  
               } Nocase-re "\ (sí / no \)" {
                  enviar "sí \ r"
                  exp_continue

               # A continuación se encarga de la s / n solicita  
               } Nocase-re "- continúa -" {
                  enviar ""
                  exp_continue
                                          
               # A continuación se encarga de la pronta normales para detectar cuando se conectó
               } Nocase-re "$ mensaje" {
                  pone "\ n - ÉXITO para el normal indicador de entrada - \ n"
               }
            }
                
         }
      }
      
      # Ahora que hemos terminado, envía una salida
      pone "*** Acabado con guión"
      enviar "exit \ r"
      dormir 1
   }

# # FIN DE LA ESCRITURA DE # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

Ejemplos

ASA show version utilizando TELNET

[Red @ red bin] $. / Vty_runcmd.exp-h 172.16.0.33-u tim-p userpass-e enablepass
hostname = 172.16.0.33, user = tim, pw = userpass, method = telnet
Introduzca el texto de envío (tipo "fin" en la última línea hasta el final):
mostrar la versión
final
Conexión mediante telnet a 172.16.0.33 como usuario tim
generar telnet 172.16.0.33
Uso de la identificación de procesos: 13811
Tratando 172.16.0.33 ...
Conectado con el FP-N1-7-FWSM-P1 (172.16.0.33).
Carácter de escape es '^]'.
- ================================================= ================== -
Se prohíbe el acceso no autorizado |! |
| |
- ================================================= ================== -


Verificación de acceso de usuario

Advertencia: La autenticación está habilitada para el contexto del sistema. Usar las credenciales de administrador de contexto.

Nombre de usuario: tim
Contraseña: ********
Escriba ayuda o '?' para obtener una lista de comandos disponibles.
FP-N1-7-FWSM-P1/PartnerFW> 
ÉXITO: ​​Conectado y listo para enviar comandos

*** Uso del modo de habilitación
permitir
Contraseña: ********
FP-N1-7-FWSM-P1/PartnerFW # - El éxito en el modo enable -
mostrar la versión

FWSM Firewall Versión 4.0 (6) <context>
Device Manager Versión 6.1 (5) F

Compilado de lun 22-jun-09 02:33 por fwsmbld

FP-N1-7-FWSM-P1 hasta 55 días 11 horas
clúster de conmutación de hasta 116 días 12 horas

Hardware: WS-SVC-FWM-1
La clave de activación ejecución no se ha establecido, con la configuración predeterminada:

Funciones con licencia de este contexto de usuario:
Failover: Activo / Activo
VPN-DES: Habilitado   
VPN-3DES-AES: Habilitado   
GTP / GPRS: Desactivado  
BGP Stub: Desactivado  
Aceleración de servicios: Discapacitados  

Configuración Última modificación por tim en 23:42:12.528 UTC lun 01 de noviembre 2009
FP-N1-7-FWSM-P1/PartnerFW # 
- Pedirá ÉXITO de inicio de sesión normal -

*** Acabado con guión
[Red @ red bin] $

ASA show version usando SSH - acepta automáticamente las claves RSA

[Red @ red ~] $ bin / vty_runcmd.exp-m ssh-h 172.16.0.33-u tim-p userpass-e enablepass
hostname = 172.16.0.33, user = tim, pw = userpass, method = ssh
Introduzca el texto de envío (tipo "fin" en la última línea hasta el final):
espectáculo ver
final
Conexión mediante ssh a 172.16.0.33 como usuario tim
generar ssh tim@172.16.0.33
Uso de la identificación de procesos: 14855
La autenticidad de acogida '172 .16.0.33 (172.16.0.33) 'no se puede establecer.
RSA huella digital es 1d: 81:48:7 e: ec: 5a: ba: e1: f5: e5: a3: 92:41: a8: 6a: 61.
¿Está seguro de que desea continuar la conexión (sí / no)? sí
Advertencia: Permanentemente añadido .16.0.33 '172 '(RSA) a la lista de hosts conocidos.
tim@172.16.0.33 's contraseña: 
- ================================================= ================== -
Se prohíbe el acceso no autorizado |! |
| |
- ================================================= ================== -
Escriba ayuda o '?' para obtener una lista de comandos disponibles.
FP-N1-7-FWSM-P1/PartnerFW> 
ÉXITO: ​​Conectado y listo para enviar comandos

*** Uso del modo de habilitación
permitir
Contraseña: ********
FP-N1-7-FWSM-P1/PartnerFW # - El éxito en el modo enable -
espectáculo ver

FWSM Firewall Versión 4.0 (6) <context>
Device Manager Versión 6.1 (5) F

Compilado de lun 22-jun-09 02:33 por fwsmbld

FP-N1-7-FWSM-P1 hasta 55 días 11 horas
clúster de conmutación de hasta 116 días 12 horas

Hardware: WS-SVC-FWM-1
La clave de activación ejecución no se ha establecido, con la configuración predeterminada:

Funciones con licencia de este contexto de usuario:
Failover: Activo / Activo
VPN-DES: Habilitado   
VPN-3DES-AES: Habilitado   
GTP / GPRS: Desactivado  
BGP Stub: Desactivado  
Aceleración de servicios: Discapacitados  

Configuración modificada por última vez por enable_15 al 06:05:31.674 UTC lun 01 de noviembre 2009
FP-N1-7-FWSM-P1/PartnerFW # 
- Pedirá ÉXITO de inicio de sesión normal -

*** Acabado con guión
[Red @ red ~] $

No hay comentarios:

Publicar un comentario

Suscribirse a: Entradas (Atom)

Mi lista de blogs