def __init__(self, ip, port):
self.ip = ip
self.port = port
self.env_creds = env_file.get(path="env\ssh")
self.ssh_details = {
"device_type": "cisco_ios",
"ip": self.ip,
"port": self.port,
"username": self.env_creds["SSH_USERNAME"],
"password": self.env_creds["SSH_PASSWORD"],
"secret": self.env_creds["SSH_SECRET"]
}
self.ssh_session = Netmiko(**self.ssh_details)
self.ssh_session.enable()
def show_arp(x_ip):
my_device = {
"host": x_ip,
"username": "******",
"password": "******",
"device_type": "cisco_ios",
}
try:
net_connect = Netmiko(**my_device)
arp_res = net_connect.send_command('show ip arp')
net_connect.disconnect()
return arp_res #return一定要写在最后
except:
print("Something wrong")
def save_loc():
start = time.time()
with open('router.list') as f:
ip_r = f.read().splitlines()
with open('switch.list') as f:
ip_s = f.read().splitlines()
ip_add = ip_r + ip_s
#On parcourt la liste d'IP
for ip in ip_add:
print("Sauvegarde de la configuration de l'équipement ayant l'adresse : "+ ip)
equipment = {
'device_type': 'cisco_ios',
'ip': ip,
'username': username,
'password': password,
}
#On initialise la connexion Netmiko sur l'équipement cible
net_connect = Netmiko(**equipment)
#récupération de la running-config
run_cnf = net_connect.send_command("show running-config")
print("Configuration Sauvegardée : "+ "\n" + run_cnf)
now = datetime.now()
date = now.strftime("%d_%m_%Y")
#Récupération du hostname
def hostname():
hst = net_connect.send_command("show running-config | in hostname")
hostname = hst.split()
return hostname[1]
path_save = "save/{0}/".format(hostname())
#Création du dossier de backup si nécessaire
try:
os.makedirs(path_save)
except:
pass
file_save = "save/{0}/{1}.txt".format(hostname(),date)
#Ajoute la configuration au fichier texte créer ci dessus
with open(file_save, "a") as file:
file.write(run_cnf + "\n")
print("Configuration Sauvegardée dans le fichier:" + file_save +"\n")
net_connect.disconnect()
duration(start)
def deviceconnector(i,q):
# This while loop runs indefinitely and grabs IP addresses from the queue and processes them
# Loop will stop and restart if "ip = q.get()" is empty
while True:
# These print statements are largely for the user indicating where the process is at
# and aren't required
print("{}: Waiting for IP address...".format(i))
ip = q.get()
print("{}: Acquired IP: {}".format(i,ip))
# k,v passed to net_connect
device_dict = {
'host': ip,
'username': '******',
'password': password,
'device_type': 'cisco_ios'
}
# Connect to the device, and print out auth or timeout errors
try:
net_connect = Netmiko(**device_dict)
except NetMikoTimeoutException:
with print_lock:
print("\n{}: ERROR: Connection to {} timed-out.\n".format(i,ip))
q.task_done()
continue
except NetMikoAuthenticationException:
with print_lock:
print("\n{}: ERROR: Authenticaftion failed for {}. Stopping script. \n".format(i,ip))
q.task_done()
os.kill(os.getpid(), signal.SIGUSR1)
# Capture the output, and use TextFSM (in this case) to parse data
output = net_connect.send_command(command,use_textfsm=True)
with print_lock:
print("{}: Printing output...".format(i))
pprint(output)
# Disconnect from device
net_connect.disconnect
# Set the queue task as complete, thereby removing it from the queue indefinitely
q.task_done()
def dhcp_client(ip):
interface = input(show_input("Specify target interface : "))
net_connect = Netmiko(**get_dic(ip))
print("-------------------------------------------------")
net_connect.enable()
enable = [interface, 'ip address dhcp', 'no sh']
conf_t = net_connect.send_config_set(enable)
print(conf_t)
print("-------------------------------------------------")
# Affiche l'IP reçue par le DHCP
show_result("You got {0} from DHCP".format(get_ip_dhcp(ip)))
# Demande de write la conf
save = input(show_input("Do you want to write configuration ? (y/n) : "))
if save == "y" or save == "yes":
write_conf(ip)
end_task()
print("-------------------------------------------------")
def connect(self):
print(f"\n\n----- Connecting to {self.hostname}:{self.port}")
try:
self.connection = Netmiko(
self.hostname,
port=self.port,
username=self.username,
password=self.password,
device_type=self.device_type,
)
except:
self.connection = None
print("----- Could not connect --------------------")
return False
print(f"----- Connected! --------------------")
return True
def backupH(ips):
try:
hirschmann_IOS = {
'device_type': 'cisco_ios',
'host': ips,
'username': username,
'password': password,
'secret': password,
'timeout': 10000,
'session_timeout': 10000
}
net_connect = Netmiko(**hirschmann_IOS)
net_connect.enable()
out = net_connect.send_command(
"copy config running-config remote tftp://" + tftp_ip + "/OSC." +
ips + ".xml")
net_connect.disconnect()
except ValueError:
pass
except NetMikoTimeoutException:
print("ERROR: connection to " + ips + " timed-out.\n")
except NetMikoAuthenticationException:
print("ERROR: Authenticaftion failed for " + ips)
def hello():
try:
print(request)
json_data = request.get_json(force=True)
print(json_data)
router_name = json_data['router']
interface = json_data['interface']
# get ip from router
#start for router config
net_connect = Netmiko(**cisco1)
# command = "show ip int brief"
command = ("show ip int brief")
print()
# print(net_connect.find_prompt())
output = net_connect.send_command(command)
net_connect.disconnect()
# print(output)
newStr = output.split("Protocol", 1)[1]
# res= newStr[0:40]
res = newStr[0:40]
newres = ' '.join(res.split())
result = newres.split(' ')[1]
#print('*********************************')
#print(res)
#print('#####')
#print(result)
# print()
#end of router add
#ipadd = "10.20.0.0"
return jsonify(ip=result)
#end of router add
#ipadd = "10.20.0.0"
# return jsonify(ip = output)
except Exception as e:
print(e)
print("Something went wrong")
def make_connection_to_device():
'''Helper invoked from main() to set up a netmiko connection to the
device, and put it into enable mode'''
# access the netrc to read the credentials
try:
rc = netrc.netrc()
except FileNotFoundError as e:
print('(Failed to access netrc file for gathering ',
'login credentials: {})'.format(str(e)), file=sys.stderr)
sys.exit(-1)
netmiko_device_info = {}
netmiko_device_info['host'] = DESIRED_SETTINGS['device']
netmiko_device_info['device_type'] = 'cisco_ios'
try:
host = netmiko_device_info['host']
(login, enable_password, password) = rc.authenticators(host)
except TypeError:
print('No entry in netrc file for device "{}", and no default '
'either.'.format(netmiko_device_info['host']), file=sys.stderr)
sys.exit(-1)
# Fill in the user name / password / enable password device_info
# attributes from the info we read from .netrc
netmiko_device_info['username'] = login
netmiko_device_info['password'] = password
if enable_password:
netmiko_device_info['secret'] = enable_password
print('Connecting to device_info "{}"...'.format(
netmiko_device_info['host']), end='', flush=True)
device = Netmiko(**netmiko_device_info)
print('connected.')
print('Entering enable mode...', end='', flush=True)
device.enable()
print('done.')
prompt = device.find_prompt()
print('Prompt is "{}"'.format(prompt))
return device
def proxy_vsr():
vsr_host = {
"host": vsr, # Far-end vSR behind JumpServer
"username": "******", # Username to the vSR should never change.
"password": "******", # Password to the vSR should never change.
"device_type": "alcatel_sros",
"ssh_config_file":
"~/.ssh/config", # location of the ssh config on the local machine running this script, in order to use jumpserver as proxy.
}
net_connect = Netmiko(**vsr_host)
# Display the Chassis type to screen.
system_type = net_connect.send_command(
'show system information | match "System Type"')
execute = f"Executing Commands on vSR: {system_type} Using the file: {ftp_file}"
print(execute)
syntax = net_connect.send_command('exec -syntax ' + 'ftp://*****:*****@' +
JumpServer + '/pub/vzw/' + ftp_file)
if 'Verified' in syntax:
print("Syntax Check Verified. Executing configuration.")
else:
print(syntax)
syntax = net_connect.send_command('exec ' + 'ftp://*****:*****@' + JumpServer +
'/pub/vzw/' + ftp_file,
expect_string=r'#')
if 'failed' in syntax:
print(":: Failed ::: " + syntax)
else:
print(syntax)
net_connect.disconnect()
def backup(ips):
try:
cisco_IOS = {
'device_type': 'cisco_ios',
'host': ips,
'username': username,
'password': password,
'secret': password,
'timeout': 10000,
'session_timeout': 10000
}
net_connect = Netmiko(**cisco_IOS)
net_connect.enable()
out = net_connect.send_command("show running-config")
net_connect.disconnect()
with open(path + '/' + ips + '.txt', 'w') as fileouts:
fileouts.write(out)
except ValueError:
pass
except NetMikoTimeoutException:
print("ERROR: connection to " + ips + " timed-out.\n")
except NetMikoAuthenticationException:
print("ERROR: Authenticaftion failed for " + ips)
def main():
timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
# Get input from user
while True:
try:
subnets = input(
"Enter a subnet(s) (CIDR notation, space delimited): ").split(
)
for i in range(0, len(subnets)):
subnets[i] = ipaddress.IPv4Network(subnets[i])
except:
if input(
"Invalid data entered. Press any key to continue or 'q' to quit. "
) == 'q':
exit()
else:
break
if len(subnets) > 0:
# gather username and password
cisco_user = input("Device Username: "******"Device Password: "******"Please wait while inventory report is being generated")
# Open csv file for write operation
with open(f'{os.getcwd()}/discovered_switches_{timestamp}.csv',
'w') as csv_file:
report_writer = csv.writer(csv_file,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_MINIMAL)
report_writer.writerow(['Hostname', 'IP Address', 'Model'])
for subnet in subnets:
for ip in subnet.hosts():
# Create connection object for Netmiko
conn = {
"host": str(ip),
"username": cisco_user,
"password": cisco_pass,
"device_type": "cisco_ios",
}
# Attempt connection
try:
net_connect = Netmiko(**conn)
vers = net_connect.send_command('show version')
except:
print(f"Error connecting to {str(ip)}")
else:
hostname = net_connect.find_prompt().split('#')[0]
model = net_connect.send_command(
'show inventory | inc PID').splitlines()[0].split(
',')[0].lstrip('PID:').strip()
report_writer.writerow([hostname, str(ip), model])
net_connect.disconnect()
print(f"Completed successfully on {str(ip)}")
def push_config(self):
for node in self.data["site_list"]:
net_connect = Netmiko(**node['login'])
with open('commands/XC_command_{}_create.txt'.format(node["Node_name"]),'r') as f:
f2 = f.readlines()
output = net_connect.send_config_set(f2)
if node['login']['device_type'] == 'cisco_xr':
net_connect.commit()
else:
pass
#print(output)
print("**** Configration completed on {}".format(node['Node_name']))
net_connect.exit_config_mode()
net_connect.disconnect()
def config_change(ips):
try:
cisco_IOS = {
'device_type': 'cisco_ios',
'host': ips,
'username': username,
'password': password,
'secret': password,
'timeout': 10000,
'session_timeout': 10000
}
net_connect = Netmiko(**cisco_IOS)
net_connect.enable()
with open('config_change.txt') as commands:
command = commands.read().splitlines()
# g_output = net_connect.send_config_from_file(config_file="config_change.txt")
g_output = net_connect.send_config_set(command)
net_connect.disconnect()
return "-----------Working on host " + ips + " -----------\n" + g_output + "\n"
# except ValueError:
except NetMikoTimeoutException:
w = open('status_output.txt', 'a')
w.write("ERROR: connection to " + ips + " timed-out.")
w.close()
except NetMikoAuthenticationException:
k = open('status_output.txt', 'a')
k.write("ERROR: Authentication failed for " + ips)
k.close()
def status_check(ips):
try:
cisco_IOS = {
'device_type': 'cisco_ios',
'host': ips,
'username': username,
'password': password,
'secret': password,
'timeout': 10000,
'session_timeout': 10000
}
net_connect = Netmiko(**cisco_IOS)
net_connect.enable()
with open('status_check.txt') as command:
output = ''
for commands in command:
output += "=====>" + commands + net_connect.send_command(
commands) + '\n'
net_connect.disconnect()
return "-----> Working on host " + ips + " <-----" "\n" + output + "\n"
except ValueError:
pass
except NetMikoTimeoutException:
print("ERROR: connection to " + ips + " timed-out.\n")
except NetMikoAuthenticationException:
print("ERROR: Authentication failed for " + ips)
def main():
my_device = {
'host': 'ios-xe-mgmt.cisco.com',
'username': '******',
'password': '******',
'device_type': 'cisco_ios',
'port': 8181
}
net_connect = Netmiko(**my_device)
routes = net_connect.send_command('sh ip route', use_textfsm=True)
neigbors = net_connect.send_command('sh cdp neighbor', use_textfsm=True)
arp_entries = net_connect.send_command('sh ip arp', use_textfsm=True)
print("ROUTES : \n")
for route in routes:
print(route)
print("NEIGHBORS : \n")
if type(neigbors) == list:
for nei in neigbors:
print(nei)
print("ARPs : \n")
for arp in arp_entries:
print(arp)
net_connect.disconnect()
def getLicense(host, user, passwd):
net_connect = Netmiko(
host, username=user, password=passwd, device_type="juniper_junos"
)
command = "show system license"
print("Logging in as " + user)
print("*" * 30)
# print(net_connect.find_prompt())
print()
print("Sending command: " + command)
output = net_connect.send_command(command)
print(output)
print()
print("Logging out and closing session . . .")
net_connect.disconnect()
def get_arp_ios(host_dict, vrf=""):
hostname = host_dict['host']
#print("Trying connection to " + hostname)
try:
# Establish connection
connection = Netmiko(**host_dict)
except:
print("get_arp_ios - Could not establish ssh connection to host" + hostname)
return -1
# Run command with textfsm - this should return structured data
#print("Running command")
if vrf == "":
output = connection.send_command("sh ip arp", use_textfsm = True)
else:
output = connection.send_command("sh ip arp vrf " + vrf, use_textfsm = True)
# Return structured data
#print("Returning output")
return output
def Input(ip):
my_device = {
"host": ip,
"username": "******",
"password": "******",
"device_type": "cisco_ios",
}
try:
net_connect = Netmiko(
**my_device) #Netmiko是一个类，net_connect是一个实例，my_device是产生实例时需要的数据属性
result = net_connect.send_config_from_file(
config_file='commands.txt'
) #通过实例去调用类函数，实例本身并没有函数属性，是通过风湿理论去调用类里的函数
net_connect.disconnect()
return "done"
except:
return "something wrong"
def sendCommand(self, commandStr, fileName="noname"):
my_device = {}
my_device.update({"host": self.ip_addr})
my_device.update({"username": self.username})
my_device.update({"password": self.password})
my_device.update({"device_type": self.deviceType})
print(my_device)
net_connect = Netmiko(**my_device)
output = net_connect.send_command(commandStr)
# f = open(...)
if fileName == "noname":
fileName = "outputs/" + self.hostname + ".cfg"
with open(fileName, "w", encoding="utf-8") as f:
f.write(output)
def check_bri(self):
cmd = [
'config vdom', 'edit SERVICES',
f'get router info routing-table details | grep {svrbri}'
]
device = {
'ip': 'extfw-a',
'username': self.username,
'password': self.password,
'use_keys': self.keys,
'device_type': 'fortinet',
}
net_connect = Netmiko(**device, fast_cli=True)
for command in cmd[:-1]:
net_connect.send_command(command, expect_string=r"#")
gateway = re.findall(r'[0-9]+(?:\.[0-9]+){3}',
net_connect.send_command(cmd[-1]))[-1]
return gateway
def check_if_vlan_exists():
req_data = request.get_json(force=True)
vlan_id = req_data['vlan_id']
vlan_name = req_data['vlan_name']
cisco = {
'device_type': 'cisco_ios',
'ip': '172.16.200.2',
'username': '******',
'password': '******'
}
switches = [cisco]
for devices in switches:
net_connect = Netmiko(**devices)
command = "show vlan"
# print()
# print(net_connect.find_prompt())
output = net_connect.send_command(command)
net_connect.disconnect()
lines = output.split('\n')
id_arr = []
name_arr = []
for x in range(2, len(lines) - 8):
id = lines[x].split(' ')[0]
id_arr.append(id)
if len(id) == 1:
name = lines[x].split(' ')[4]
if len(id) == 2:
name = lines[x].split(' ')[3]
if len(id) == 3:
name = lines[x].split(' ')[2]
if len(id) == 4:
name = lines[x].split(' ')[1]
name_arr.append(name)
if vlan_id in id_arr and vlan_name in name_arr:
print(f"vlan {vlan_name} already exists")
return "false"
elif vlan_id in id_arr:
print(f"vlan {vlan_id} already exists")
return "id"
elif vlan_name in name_arr:
print(f"Name {vlan_name} already exists")
return "name"
else:
return "true"
def delete_config(self):
for node in self.data["site_list"]:
net_connect = Netmiko(**node['login'])
with open(
'templates/XC_command_{}_delete.txt'.format(
node["Node_name"]), 'r') as f:
f2 = f.readlines()
output = net_connect.send_config_set(f2)
print(output)
if node['login']['device_type'] == 'cisco_xr':
net_connect.commit()
else:
pass
net_connect.exit_config_mode()
net_connect.disconnect()
def main():
"""
Execution starts here.
"""
# Read the hosts file into structured data, may raise YAMLError
with open("hosts.yml", "r") as handle:
host_root = safe_load(handle)
# Load the generic variables for all devices outside of the loop
with open("vars/inputs.yml", "r") as handle:
data = safe_load(handle)
# Iterate over the list of hosts (list of dictionaries)
for host in host_root["production"]:
# Setup the jinja2 templating environment and render the template
j2_env = Environment(loader=FileSystemLoader("."),
trim_blocks=True,
autoescape=True)
template = j2_env.get_template("templates/routing.j2")
new_config = template.render(data=data)
# Create netmiko SSH connection handler to access the device
conn = Netmiko(
host=host["name"],
username="******",
password="******",
device_type="cisco_ios",
)
print(f"Logged into {conn.find_prompt()} successfully")
# Send the configuration string to the device. Netmiko
# takes a list of strings, not a giant \n-delimited string,
# so use the .split() function
result = conn.send_config_set(new_config.split("\n"))
# Netmiko automatically collects the results; you can ignore them
# or process them further
print(result)
conn.disconnect()
def showint():
array = []
array = read_excel('Zhu_list.xlsx', 0)
b = len(array)
for j in range(1, b):
print(array[j][2], array[j][3], array[j][4])
my_device = {
"host": array[j][2],
"username": array[j][4],
"password": array[j][5],
"device_type": "cisco_ios",
}
net_connect = Netmiko(**my_device)
output = net_connect.send_command("show ip int brief")
print(output)
net_connect.disconnect()
def netmiko_connect(device_type):
print(
f"\n\nConnecting to {cisco_sandbox_device[device_type]['ip']}:{cisco_sandbox_device[device_type]['port']}"
)
print("... this may take a little while.")
connection = Netmiko(**cisco_sandbox_device[device_type])
return connection
def netmiko_config_cred(host, username, password, cmds_list, enable='Cisc0123', ssh=True, verbose=False):
device_info = {
'host': host,
'username': username,
'password': password,
'device_type': 'cisco_ios' if ssh else 'cisco_ios_telnet',
'secret': enable
}
try:
net_connect = Netmiko(**device_info)
if verbose:
output = net_connect.send_config_set(cmds_list)
return output
else:
net_connect.send_config_set(cmds_list)
except Exception as e:
print(f'connection error ip: {host} error: {str(e)}')
return
def main(argv):
"""
Execution starts here.
"""
# Read the hosts file into structured data, may raise YAMLError
with open("hosts.yml", "r") as handle:
host_root = safe_load(handle)
# Netmiko uses "cisco_ios" instead of "ios" and
# "cisco_xr" instead of "iosxr", so use a mapping dict to convert
platform_map = {"ios": "cisco_ios", "iosxr": "cisco_xr"}
# Iterate over the list of hosts (list of dictionaries)
for host in host_root["host_list"]:
# Use the map to get the proper Netmiko platform
platform = platform_map[host["platform"]]
# Initialize the SSH connection
print(f"Connecting to {host['name']}")
conn = Netmiko(
host=host["name"],
username="******",
password="******",
device_type=platform,
)
# Upload the file specified. The dict.get(key) function tries
# to retrieve the value at the specified key and returns None
# if it does not exist. Very useful in network automation!
print(f" Uploading {argv[1]}")
result = file_transfer(
conn,
source_file=argv[1],
dest_file=argv[1],
file_system=host.get("file_system"),
)
# Print the resulting details
print(f" Details: {result}\n")
conn.disconnect()
def worker(host, jobs):
""" Обработчик заданий
"""
device = {
"device_type": "cisco_ios",
"host": host,
"username": USERNAME,
"password": PASSWORD,
"secret": SECRET
}
con = Netmiko(**device)
if con.find_prompt():
device = {"con": con, "host": host}
result = [host]
for job in jobs:
result.append(job(**device))
return result
else:
return "Не удалось подключиться к f{host}"
def command_firewall(self, hosts, set_command):
device = {
'ip': hosts,
'username': self.username,
'password': self.password,
'use_keys': self.keys,
'device_type': 'fortinet',
}
try:
net_connect = Netmiko(**device, fast_cli=True)
if isinstance(set_command, list):
result = []
for command in set_command:
result.append(net_connect.send_command(command))
return result
else:
return net_connect.send_command(set_command,
auto_find_prompt=False)
except paramiko.ssh_exception.AuthenticationException:
print("\nWrong Password\n")
try:
host = raw_input("Enter host to connect to: ")
except NameError:
host = input("Enter host to connect to: ")
password = getpass()
device = {
'host': host,
'username': '******',
'password': password,
'device_type': 'cisco_ios',
}
filename = 'smallfile'
command = 'delete flash:{}'.format(filename)
net_connect = Netmiko(**device)
output = net_connect.send_command_timing(command, strip_prompt=False, strip_command=False)
if 'confirm' in output:
# I don't confirm the file delete.
output += net_connect.send_command_timing('n', strip_prompt=False, strip_command=False)
else:
raise ValueError("Expected confirm message in output")
print()
print('-' * 80)
print(output)
print('-' * 80)
print()
#!/usr/bin/env python
from netmiko import Netmiko
from getpass import getpass
cisco1 = {
'host': 'cisco1.twb-tech.com',
'username': '******',
'password': getpass(),
'device_type': 'cisco_ios',
}
net_connect = Netmiko(**cisco1)
command = 'copy flash:c880data-universalk9-mz.154-2.T1.bin flash:test1.bin'
print()
print(net_connect.find_prompt())
output = net_connect.send_command(command, delay_factor=4)
print(output)
print()
#!/usr/bin/env python
from netmiko import SSHDetect, Netmiko
from getpass import getpass
device = {
'device_type': 'autodetect',
'host': 'cisco1.twb-tech.com',
'username': '******',
'password': getpass(),
}
guesser = SSHDetect(**device)
best_match = guesser.autodetect()
print(best_match) # Name of the best device_type to use further
print(guesser.potential_matches) # Dictionary of the whole matching result
device['device_type'] = best_match
connection = Netmiko(**device)
print(connection.find_prompt())
#!/usr/bin/env python
from __future__ import print_function, unicode_literals
# Netmiko is the same as ConnectHandler
from netmiko import Netmiko
from getpass import getpass
my_device = {
'host': "host.domain.com",
'username': '******',
'password': getpass(),
'device_type': 'cisco_ios',
}
net_connect = Netmiko(**my_device)
# Ensure in enable mode
net_connect.enable()
print(net_connect.find_prompt())
net_connect.disconnect()
#!/usr/bin/env python
from netmiko import Netmiko
from getpass import getpass
cisco1 = {
"host": "cisco1.twb-tech.com",
"username": "******",
"password": getpass(),
"device_type": "cisco_ios",
}
net_connect = Netmiko(**cisco1)
command = "del flash:/test1.txt"
print()
print(net_connect.find_prompt())
output = net_connect.send_command_timing(command)
if "confirm" in output:
output += net_connect.send_command_timing(
"y", strip_prompt=False, strip_command=False
)
net_connect.disconnect()
print(output)
print()
#!/usr/bin/env python
from __future__ import print_function, unicode_literals
# Netmiko is the same as ConnectHandler
from netmiko import Netmiko
from getpass import getpass
my_device = {
'host': "host.domain.com",
'username': '******',
'password': getpass(),
'device_type': 'cisco_ios',
# Increase (essentially) all sleeps by a factor of 2
'global_delay_factor': 2,
}
net_connect = Netmiko(**my_device)
# Increase the sleeps for just send_command by a factor of 2
output = net_connect.send_command("show ip int brief", delay_factor=2)
print(output)
net_connect.disconnect()
#!/usr/bin/env python
from __future__ import print_function, unicode_literals
# Netmiko is the same as ConnectHandler
from netmiko import Netmiko
from getpass import getpass
my_device = {
'host': 'host.domain.com',
'username': '******',
'password': getpass(),
'device_type': 'cisco_ios',
}
net_connect = Netmiko(**my_device)
output = net_connect.send_command("show ip int brief")
print(output)
net_connect.disconnect()
"""
Optional, use send_command() in conjunction with ntc-templates to execute a show command. Have
TextFSM automatically convert this show command output to structured data.
"""
from __future__ import print_function, unicode_literals
from netmiko import Netmiko
from getpass import getpass
from pprint import pprint
try:
host = raw_input("Enter host to connect to: ")
except NameError:
host = input("Enter host to connect to: ")
password = getpass()
device = {
'host': host,
'username': '******',
'password': password,
'device_type': 'cisco_ios',
}
command = 'show ip int brief'
net_connect = Netmiko(**device)
output = net_connect.send_command(command, use_textfsm=True)
print()
print('-' * 80)
pprint(output)
print('-' * 80)
print()
#!/usr/bin/env python
from netmiko import Netmiko
from getpass import getpass
R01 = {
"host": "192.168.1.32",
"username": "******",
"password": getpass(),
"device_type": "cisco_ios",
}
cfg_file = "config_changes.txt"
net_connect = Netmiko(**R01)
# routing table before change #
command = "show ip route"
print('routes PRE changes')
print(net_connect.find_prompt())
pre_routes = net_connect.send_command(command)
print(pre_routes)
print()
# make changes #
print()
print(net_connect.find_prompt())
output = net_connect.send_config_from_file(cfg_file)
print(output)
print()
# routing table after changes #
print('routes POST changes')
#!/usr/bin/env python
from __future__ import print_function, unicode_literals
# Netmiko is the same as ConnectHandler
from netmiko import Netmiko
from getpass import getpass
my_device = {
'host': 'host.domain.com',
'username': '******',
'password': getpass(),
'device_type': 'cisco_ios',
}
net_connect = Netmiko(**my_device)
# Requires ntc-templates to be installed in ~/ntc-templates/templates
output = net_connect.send_command("show ip int brief", use_textfsm=True)
print(output)
#!/usr/bin/env python
from netmiko import Netmiko
from getpass import getpass
nxos1 = {
"host": "nxos1.twb-tech.com",
"username": "******",
"password": getpass(),
"device_type": "cisco_nxos",
}
commands = ["logging history size 500"]
net_connect = Netmiko(**nxos1)
print()
print(net_connect.find_prompt())
output = net_connect.send_config_set(commands)
output += net_connect.send_command("copy run start")
print(output)
print()
#!/usr/bin/env python
from __future__ import print_function, unicode_literals
# Netmiko is the same as ConnectHandler
from netmiko import Netmiko
from getpass import getpass
my_device = {
'host': "host.domain.com",
'username': '******',
'password': getpass(),
'device_type': 'cisco_ios',
}
net_connect = Netmiko(**my_device)
# Make configuration changes using an external file
output = net_connect.send_config_from_file("change_file.txt")
print(output)
net_connect.disconnect()
try:
host = raw_input("Enter host to connect to: ")
except NameError:
host = input("Enter host to connect to: ")
password = getpass()
device = {
'host': host,
'username': '******',
'password': password,
'device_type': 'cisco_ios',
}
net_connect = Netmiko(**device)
# Use send_config_set() to make config change
config = ['logging console', 'logging buffer 15000']
output = net_connect.send_config_set(config)
output_printer(output)
# Use send_config_from_file() to make config change
output = net_connect.send_config_from_file('config.txt')
output_printer(output)
message = "Verifying config change\n"
output = net_connect.send_command("show run | inc logging")
if '8000' in output:
message += "Logging buffer is size 8000"
#!/usr/bin/env python
from netmiko import Netmiko
from getpass import getpass
key_file = "/home/gituser/.ssh/test_rsa"
cisco1 = {
"device_type": "cisco_ios",
"host": "cisco1.twb-tech.com",
"username": "******",
"use_keys": True,
"key_file": key_file,
}
net_connect = Netmiko(**cisco1)
print(net_connect.find_prompt())
output = net_connect.send_command("show ip arp")
print(output)
#!/usr/bin/env python
from netmiko import Netmiko
from getpass import getpass
net_connect = Netmiko(
"cisco1.twb-tech.com",
username="******",
password=getpass(),
device_type="cisco_ios",
)
print(net_connect.find_prompt())
net_connect.disconnect()
#!/usr/bin/env python
from netmiko import Netmiko
from getpass import getpass
cisco1 = {
"host": "cisco1.twb-tech.com",
"username": "******",
"password": getpass(),
"device_type": "cisco_ios",
}
net_connect = Netmiko(**cisco1)
command = "show ip int brief"
print()
print(net_connect.find_prompt())
output = net_connect.send_command(command)
net_connect.disconnect()
print(output)
print()
#!/usr/bin/env python
from netmiko import Netmiko
from getpass import getpass
password = getpass()
cisco1 = {
'host': 'cisco1.twb-tech.com',
'username': '******',
'password': password,
'device_type': 'cisco_ios',
'secret': password,
}
net_connect = Netmiko(**cisco1)
print(net_connect.find_prompt())
net_connect.send_command_timing("disable")
print(net_connect.find_prompt())
net_connect.enable()
print(net_connect.find_prompt())
# Go into config mode
net_connect.config_mode()
print(net_connect.find_prompt())
net_connect.exit_config_mode()
print(net_connect.find_prompt())
net_connect.disconnect()
from getpass import getpass
my_device = {
"host": "host.domain.com",
"username": "******",
"password": getpass(),
"device_type": "cisco_ios",
}
"""
Cisco IOS behavior on file delete:
pynet-rtr1# delete flash:/small_file_bim.txt
Delete flash:/test1.txt? [confirm]y
pynet-rtr1
"""
net_connect = Netmiko(**my_device)
filename = "text1234.txt"
cmd = "delete flash:{}".format(filename)
# send_command_timing as the router prompt is not returned
output = net_connect.send_command_timing(cmd, strip_command=False, strip_prompt=False)
if "confirm" in output:
output += net_connect.send_command_timing(
"\n", strip_command=False, strip_prompt=False
)
net_connect.disconnect()
print(output)
# SNMPv3
from netmiko.snmp_autodetect import SNMPDetect
from netmiko import Netmiko
from getpass import getpass
device = {
'host': 'cisco1.twb-tech.com',
'username': '******',
'password': getpass(),
}
snmp_key = getpass("Enter SNMP community: ")
my_snmp = SNMPDetect("cisco1.twb-tech.com", snmp_version="v3", user='******',
auth_key=snmp_key, encrypt_key=snmp_key, auth_proto="sha",
encrypt_proto="aes128")
device_type = my_snmp.autodetect()
print(device_type)
device['device_type'] = device_type
net_connect = Netmiko(**device)
print(net_connect.find_prompt())
#!/usr/bin/env python
from __future__ import print_function, unicode_literals
# Netmiko is the same as ConnectHandler
from netmiko import Netmiko
from getpass import getpass
my_device = {
'host': "host.domain.com",
'username': '******',
'password': getpass(),
'device_type': 'cisco_ios',
}
net_connect = Netmiko(**my_device)
cfg_commands = ['logging buffered 10000', 'no logging console']
# send_config_set() will automatically enter/exit config mode
output = net_connect.send_config_set(cfg_commands)
print(output)
net_connect.disconnect()
#!/usr/bin/env python
from netmiko import Netmiko
from getpass import getpass
cisco1 = {
"host": "cisco1.twb-tech.com",
"username": "******",
"password": getpass(),
"device_type": "cisco_ios",
}
net_connect = Netmiko(**cisco1)
command = "show ip int brief"
print()
print(net_connect.find_prompt())
output = net_connect.send_command(command, use_textfsm=True)
net_connect.disconnect()
print(output)
print()
#!/usr/bin/env python
from netmiko import Netmiko
from getpass import getpass
nxos1 = {
'host': 'nxos1.twb-tech.com',
'username': '******',
'password': getpass(),
'device_type': 'cisco_nxos',
}
cfg_file = 'config_changes.txt'
net_connect = Netmiko(**nxos1)
print()
print(net_connect.find_prompt())
output = net_connect.send_config_from_file(cfg_file)
print(output)
print()
net_connect.save_config()
net_connect.disconnect()
#!/usr/bin/env python
from netmiko import Netmiko
from getpass import getpass
import time
cisco1 = {
'host': 'cisco1.twb-tech.com',
'username': '******',
'password': getpass(),
'device_type': 'cisco_ios',
}
net_connect = Netmiko(**cisco1)
print(net_connect.find_prompt())
net_connect.write_channel("show ip int brief\n")
time.sleep(1)
output = net_connect.read_channel()
print(output)
net_connect.disconnect()
#!/usr/bin/env python
from netmiko import Netmiko
from getpass import getpass
device = {
'host': 'srx1.twb-tech.com',
'username': '******',
'password': getpass(),
'device_type': 'juniper_junos',
}
commands = [
'set system syslog archive size 240k files 3 '
]
net_connect = Netmiko(**device)
print()
print(net_connect.find_prompt())
output = net_connect.send_config_set(commands, exit_config_mode=False)
output += net_connect.commit(and_quit=True)
print(output)
print()
net_connect.disconnect()
